Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(29)
Issues Repositories Search
Open Issues | Closed Issues | All Issues | Sign in with your Google Account to create issues and add comments

Side by Side Diff: trytond/tests/test_fields.py

Issue 1864045: Remove cursor, user and context instead use a Transaction (Closed)
Patch Set: Better Report.parse signature Created 14 years, 8 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « trytond/tests/test_exportdata.py ('k') | trytond/tests/test_importdata.py » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 #!/usr/bin/env python 1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*- 2 # -*- coding: utf-8 -*-
3 #This file is part of Tryton. The COPYRIGHT file at the top level of 3 #This file is part of Tryton. The COPYRIGHT file at the top level of
4 #this repository contains the full copyright notices and license terms. 4 #this repository contains the full copyright notices and license terms.
5 5 from __future__ import with_statement
6 import unittest 6 import unittest
7 import datetime 7 import datetime
8 from decimal import Decimal 8 from decimal import Decimal
9 from trytond.tests.test_tryton import POOL, DB, USER, CONTEXT, install_module 9 from trytond.tests.test_tryton import POOL, DB_NAME, USER, CONTEXT, \
10 install_module
11 from trytond.transaction import Transaction
10 12
11 13
12 class FieldsTestCase(unittest.TestCase): 14 class FieldsTestCase(unittest.TestCase):
13 ''' 15 '''
14 Test Fields. 16 Test Fields.
15 ''' 17 '''
16 18
17 def setUp(self): 19 def setUp(self):
18 install_module('test') 20 install_module('test')
19 self.boolean = POOL.get('test.boolean') 21 self.boolean = POOL.get('test.boolean')
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
54 self.date_required = POOL.get('test.date_required') 56 self.date_required = POOL.get('test.date_required')
55 57
56 self.datetime = POOL.get('test.datetime') 58 self.datetime = POOL.get('test.datetime')
57 self.datetime_default = POOL.get('test.datetime_default') 59 self.datetime_default = POOL.get('test.datetime_default')
58 self.datetime_required = POOL.get('test.datetime_required') 60 self.datetime_required = POOL.get('test.datetime_required')
59 61
60 def test0010boolean(self): 62 def test0010boolean(self):
61 ''' 63 '''
62 Test Boolean. 64 Test Boolean.
63 ''' 65 '''
64 cursor = DB.cursor() 66 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
65 67 boolean1_id = self.boolean.create({
66 boolean1_id = self.boolean.create(cursor, USER, { 68 'boolean': True,
67 'boolean': True, 69 })
68 }, CONTEXT) 70 self.assert_(boolean1_id)
69 self.assert_(boolean1_id) 71
70 72 boolean1 = self.boolean.read(boolean1_id, ['boolean'])
71 boolean1 = self.boolean.read(cursor, USER, boolean1_id, ['boolean'], 73 self.assert_(boolean1['boolean'] == True)
72 CONTEXT) 74
73 self.assert_(boolean1['boolean'] == True) 75 boolean_ids = self.boolean.search([
74 76 ('boolean', '=', True),
75 boolean_ids = self.boolean.search(cursor, USER, [ 77 ])
76 ('boolean', '=', True), 78 self.assert_(boolean_ids == [boolean1_id])
77 ], 0, None, None, CONTEXT) 79
78 self.assert_(boolean_ids == [boolean1_id]) 80 boolean_ids = self.boolean.search([
79 81 ('boolean', '!=', True),
80 boolean_ids = self.boolean.search(cursor, USER, [ 82 ])
81 ('boolean', '!=', True), 83 self.assert_(boolean_ids == [])
82 ], 0, None, None, CONTEXT) 84
83 self.assert_(boolean_ids == []) 85 boolean_ids = self.boolean.search([
84 86 ('boolean', 'in', [True]),
85 boolean_ids = self.boolean.search(cursor, USER, [ 87 ])
86 ('boolean', 'in', [True]), 88 self.assert_(boolean_ids == [boolean1_id])
87 ], 0, None, None, CONTEXT) 89
88 self.assert_(boolean_ids == [boolean1_id]) 90 boolean_ids = self.boolean.search([
89 91 ('boolean', 'in', [False]),
90 boolean_ids = self.boolean.search(cursor, USER, [ 92 ])
91 ('boolean', 'in', [False]), 93 self.assert_(boolean_ids == [])
92 ], 0, None, None, CONTEXT) 94
93 self.assert_(boolean_ids == []) 95 boolean_ids = self.boolean.search([
94 96 ('boolean', 'not in', [True]),
95 boolean_ids = self.boolean.search(cursor, USER, [ 97 ])
96 ('boolean', 'not in', [True]), 98 self.assert_(boolean_ids == [])
97 ], 0, None, None, CONTEXT) 99
98 self.assert_(boolean_ids == []) 100 boolean_ids = self.boolean.search([
99 101 ('boolean', 'not in', [False]),
100 boolean_ids = self.boolean.search(cursor, USER, [ 102 ])
101 ('boolean', 'not in', [False]), 103 self.assert_(boolean_ids == [boolean1_id])
102 ], 0, None, None, CONTEXT) 104
103 self.assert_(boolean_ids == [boolean1_id]) 105 boolean2_id = self.boolean.create({
104 106 'boolean': False,
105 boolean2_id = self.boolean.create(cursor, USER, { 107 })
106 'boolean': False, 108 self.assert_(boolean2_id)
107 }, CONTEXT) 109
108 self.assert_(boolean2_id) 110 boolean2 = self.boolean.read(boolean2_id, ['boolean'])
109 111 self.assert_(boolean2['boolean'] == False)
110 boolean2 = self.boolean.read(cursor, USER, boolean2_id, ['boolean'], 112
111 CONTEXT) 113 boolean_ids = self.boolean.search([
112 self.assert_(boolean2['boolean'] == False) 114 ('boolean', '=', False),
113 115 ])
114 boolean_ids = self.boolean.search(cursor, USER, [ 116 self.assert_(boolean_ids == [boolean2_id])
115 ('boolean', '=', False), 117
116 ], 0, None, None, CONTEXT) 118 boolean_ids = self.boolean.search([
117 self.assert_(boolean_ids == [boolean2_id]) 119 ('boolean', 'in', [True, False]),
118 120 ])
119 boolean_ids = self.boolean.search(cursor, USER, [ 121 self.assert_(boolean_ids == [boolean1_id, boolean2_id])
120 ('boolean', 'in', [True, False]), 122
121 ], 0, None, None, CONTEXT) 123 boolean_ids = self.boolean.search([
122 self.assert_(boolean_ids == [boolean1_id, boolean2_id]) 124 ('boolean', 'not in', [True, False]),
123 125 ])
124 boolean_ids = self.boolean.search(cursor, USER, [ 126 self.assert_(boolean_ids == [])
125 ('boolean', 'not in', [True, False]), 127
126 ], 0, None, None, CONTEXT) 128 boolean3_id = self.boolean.create({})
127 self.assert_(boolean_ids == []) 129 self.assert_(boolean3_id)
128 130
129 boolean3_id = self.boolean.create(cursor, USER, {}, CONTEXT) 131 boolean3 = self.boolean.read(boolean3_id, ['boolean'])
130 self.assert_(boolean3_id) 132 self.assert_(boolean3['boolean'] == False)
131 133
132 boolean3 = self.boolean.read(cursor, USER, boolean3_id, ['boolean'], 134 boolean4_id = self.boolean_default.create({})
133 CONTEXT) 135 self.assert_(boolean4_id)
134 self.assert_(boolean3['boolean'] == False) 136
135 137 boolean4 = self.boolean_default.read(boolean4_id, ['boolean'])
136 boolean4_id = self.boolean_default.create(cursor, USER, {}, CONTEXT) 138 self.assert_(boolean4['boolean'] == True)
137 self.assert_(boolean4_id) 139
138 140 self.boolean.write(boolean1_id, {
139 boolean4 = self.boolean_default.read(cursor, USER, boolean4_id, 141 'boolean': False,
140 ['boolean'], CONTEXT) 142 })
141 self.assert_(boolean4['boolean'] == True) 143 boolean1 = self.boolean.read(boolean1_id, ['boolean'])
142 144 self.assert_(boolean1['boolean'] == False)
143 self.boolean.write(cursor, USER, boolean1_id, { 145
144 'boolean': False, 146 self.boolean.write(boolean2_id, {
145 }, CONTEXT) 147 'boolean': True,
146 boolean1 = self.boolean.read(cursor, USER, boolean1_id, ['boolean'], 148 })
147 CONTEXT) 149 boolean2 = self.boolean.read(boolean2_id, ['boolean'])
148 self.assert_(boolean1['boolean'] == False) 150 self.assert_(boolean2['boolean'] == True)
149 151
150 self.boolean.write(cursor, USER, boolean2_id, { 152 transaction.cursor.rollback()
151 'boolean': True,
152 }, CONTEXT)
153 boolean2 = self.boolean.read(cursor, USER, boolean2_id, ['boolean'],
154 CONTEXT)
155 self.assert_(boolean2['boolean'] == True)
156
157 cursor.rollback()
158 cursor.close()
159 153
160 def test0020integer(self): 154 def test0020integer(self):
161 ''' 155 '''
162 Test Integer. 156 Test Integer.
163 ''' 157 '''
164 cursor = DB.cursor() 158 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
165 159 integer1_id = self.integer.create({
166 integer1_id = self.integer.create(cursor, USER, { 160 'integer': 1,
167 'integer': 1, 161 })
168 }, CONTEXT) 162 self.assert_(integer1_id)
169 self.assert_(integer1_id) 163
170 164 integer1 = self.integer.read(integer1_id, ['integer'])
171 integer1 = self.integer.read(cursor, USER, integer1_id, ['integer'], 165 self.assert_(integer1['integer'] == 1)
172 CONTEXT) 166
173 self.assert_(integer1['integer'] == 1) 167 integer_ids = self.integer.search([
174 168 ('integer', '=', 1),
175 integer_ids = self.integer.search(cursor, USER, [ 169 ])
176 ('integer', '=', 1), 170 self.assert_(integer_ids == [integer1_id])
177 ], 0, None, None, CONTEXT) 171
178 self.assert_(integer_ids == [integer1_id]) 172 integer_ids = self.integer.search([
179 173 ('integer', '=', 0),
180 integer_ids = self.integer.search(cursor, USER, [ 174 ])
181 ('integer', '=', 0), 175 self.assert_(integer_ids == [])
182 ], 0, None, None, CONTEXT) 176
183 self.assert_(integer_ids == []) 177 integer_ids = self.integer.search([
184 178 ('integer', '!=', 1),
185 integer_ids = self.integer.search(cursor, USER, [ 179 ])
186 ('integer', '!=', 1), 180 self.assert_(integer_ids == [])
187 ], 0, None, None, CONTEXT) 181
188 self.assert_(integer_ids == []) 182 integer_ids = self.integer.search([
189 183 ('integer', '!=', 0),
190 integer_ids = self.integer.search(cursor, USER, [ 184 ])
191 ('integer', '!=', 0), 185 self.assert_(integer_ids == [integer1_id])
192 ], 0, None, None, CONTEXT) 186
193 self.assert_(integer_ids == [integer1_id]) 187 integer_ids = self.integer.search([
194 188 ('integer', 'in', [1]),
195 integer_ids = self.integer.search(cursor, USER, [ 189 ])
196 ('integer', 'in', [1]), 190 self.assert_(integer_ids == [integer1_id])
197 ], 0, None, None, CONTEXT) 191
198 self.assert_(integer_ids == [integer1_id]) 192 integer_ids = self.integer.search([
199 193 ('integer', 'in', [0]),
200 integer_ids = self.integer.search(cursor, USER, [ 194 ])
201 ('integer', 'in', [0]), 195 self.assert_(integer_ids == [])
202 ], 0, None, None, CONTEXT) 196
203 self.assert_(integer_ids == []) 197 integer_ids = self.integer.search([
204 198 ('integer', 'in', []),
205 integer_ids = self.integer.search(cursor, USER, [ 199 ])
206 ('integer', 'in', []), 200 self.assert_(integer_ids == [])
207 ], 0, None, None, CONTEXT) 201
208 self.assert_(integer_ids == []) 202 integer_ids = self.integer.search([
209 203 ('integer', 'not in', [1]),
210 integer_ids = self.integer.search(cursor, USER, [ 204 ])
211 ('integer', 'not in', [1]), 205 self.assert_(integer_ids == [])
212 ], 0, None, None, CONTEXT) 206
213 self.assert_(integer_ids == []) 207 integer_ids = self.integer.search([
214 208 ('integer', 'not in', [0]),
215 integer_ids = self.integer.search(cursor, USER, [ 209 ])
216 ('integer', 'not in', [0]), 210 self.assert_(integer_ids == [integer1_id])
217 ], 0, None, None, CONTEXT) 211
218 self.assert_(integer_ids == [integer1_id]) 212 integer_ids = self.integer.search([
219 213 ('integer', 'not in', []),
220 integer_ids = self.integer.search(cursor, USER, [ 214 ])
221 ('integer', 'not in', []), 215 self.assert_(integer_ids == [integer1_id])
222 ], 0, None, None, CONTEXT) 216
223 self.assert_(integer_ids == [integer1_id]) 217 integer_ids = self.integer.search([
224 218 ('integer', '<', 5),
225 integer_ids = self.integer.search(cursor, USER, [ 219 ])
226 ('integer', '<', 5), 220 self.assert_(integer_ids == [integer1_id])
227 ], 0, None, None, CONTEXT) 221
228 self.assert_(integer_ids == [integer1_id]) 222 integer_ids = self.integer.search([
229 223 ('integer', '<', -5),
230 integer_ids = self.integer.search(cursor, USER, [ 224 ])
231 ('integer', '<', -5), 225 self.assert_(integer_ids == [])
232 ], 0, None, None, CONTEXT) 226
233 self.assert_(integer_ids == []) 227 integer_ids = self.integer.search([
234 228 ('integer', '<', 1),
235 integer_ids = self.integer.search(cursor, USER, [ 229 ])
236 ('integer', '<', 1), 230 self.assert_(integer_ids == [])
237 ], 0, None, None, CONTEXT) 231
238 self.assert_(integer_ids == []) 232 integer_ids = self.integer.search([
239 233 ('integer', '<=', 5),
240 integer_ids = self.integer.search(cursor, USER, [ 234 ])
241 ('integer', '<=', 5), 235 self.assert_(integer_ids == [integer1_id])
242 ], 0, None, None, CONTEXT) 236
243 self.assert_(integer_ids == [integer1_id]) 237 integer_ids = self.integer.search([
244 238 ('integer', '<=', -5),
245 integer_ids = self.integer.search(cursor, USER, [ 239 ])
246 ('integer', '<=', -5), 240 self.assert_(integer_ids == [])
247 ], 0, None, None, CONTEXT) 241
248 self.assert_(integer_ids == []) 242 integer_ids = self.integer.search([
249 243 ('integer', '<=', 1),
250 integer_ids = self.integer.search(cursor, USER, [ 244 ])
251 ('integer', '<=', 1), 245 self.assert_(integer_ids == [integer1_id])
252 ], 0, None, None, CONTEXT) 246
253 self.assert_(integer_ids == [integer1_id]) 247 integer_ids = self.integer.search([
254 248 ('integer', '>', 5),
255 integer_ids = self.integer.search(cursor, USER, [ 249 ])
256 ('integer', '>', 5), 250 self.assert_(integer_ids == [])
257 ], 0, None, None, CONTEXT) 251
258 self.assert_(integer_ids == []) 252 integer_ids = self.integer.search([
259 253 ('integer', '>', -5),
260 integer_ids = self.integer.search(cursor, USER, [ 254 ])
261 ('integer', '>', -5), 255 self.assert_(integer_ids == [integer1_id])
262 ], 0, None, None, CONTEXT) 256
263 self.assert_(integer_ids == [integer1_id]) 257 integer_ids = self.integer.search([
264 258 ('integer', '>', 1),
265 integer_ids = self.integer.search(cursor, USER, [ 259 ])
266 ('integer', '>', 1), 260 self.assert_(integer_ids == [])
267 ], 0, None, None, CONTEXT) 261
268 self.assert_(integer_ids == []) 262 integer_ids = self.integer.search([
269 263 ('integer', '>=', 5),
270 integer_ids = self.integer.search(cursor, USER, [ 264 ])
271 ('integer', '>=', 5), 265 self.assert_(integer_ids == [])
272 ], 0, None, None, CONTEXT) 266
273 self.assert_(integer_ids == []) 267 integer_ids = self.integer.search([
274 268 ('integer', '>=', -5),
275 integer_ids = self.integer.search(cursor, USER, [ 269 ])
276 ('integer', '>=', -5), 270 self.assert_(integer_ids == [integer1_id])
277 ], 0, None, None, CONTEXT) 271
278 self.assert_(integer_ids == [integer1_id]) 272 integer_ids = self.integer.search([
279 273 ('integer', '>=', 1),
280 integer_ids = self.integer.search(cursor, USER, [ 274 ])
281 ('integer', '>=', 1), 275 self.assert_(integer_ids == [integer1_id])
282 ], 0, None, None, CONTEXT) 276
283 self.assert_(integer_ids == [integer1_id]) 277 integer2_id = self.integer.create({
284 278 'integer': 0,
285 integer2_id = self.integer.create(cursor, USER, { 279 })
286 'integer': 0, 280 self.assert_(integer2_id)
287 }, CONTEXT) 281
288 self.assert_(integer2_id) 282 integer2 = self.integer.read(integer2_id, ['integer'])
289 283 self.assert_(integer2['integer'] == 0)
290 integer2 = self.integer.read(cursor, USER, integer2_id, ['integer'], 284
291 CONTEXT) 285 integer_ids = self.integer.search([
292 self.assert_(integer2['integer'] == 0) 286 ('integer', '=', 0),
293 287 ])
294 integer_ids = self.integer.search(cursor, USER, [ 288 self.assert_(integer_ids == [integer2_id])
295 ('integer', '=', 0), 289
296 ], 0, None, None, CONTEXT) 290 integer_ids = self.integer.search([
297 self.assert_(integer_ids == [integer2_id]) 291 ('integer', 'in', [0, 1]),
298 292 ])
299 integer_ids = self.integer.search(cursor, USER, [ 293 self.assert_(integer_ids == [integer1_id, integer2_id])
300 ('integer', 'in', [0, 1]), 294
301 ], 0, None, None, CONTEXT) 295 integer_ids = self.integer.search([
302 self.assert_(integer_ids == [integer1_id, integer2_id]) 296 ('integer', 'not in', [0, 1]),
303 297 ])
304 integer_ids = self.integer.search(cursor, USER, [ 298 self.assert_(integer_ids == [])
305 ('integer', 'not in', [0, 1]), 299
306 ], 0, None, None, CONTEXT) 300 integer3_id = self.integer.create({})
307 self.assert_(integer_ids == []) 301 self.assert_(integer3_id)
308 302
309 integer3_id = self.integer.create(cursor, USER, {}, CONTEXT) 303 integer3 = self.integer.read(integer3_id, ['integer'])
310 self.assert_(integer3_id) 304 self.assert_(integer3['integer'] == 0)
311 305
312 integer3 = self.integer.read(cursor, USER, integer3_id, ['integer'], 306 integer4_id = self.integer_default.create({})
313 CONTEXT) 307 self.assert_(integer4_id)
314 self.assert_(integer3['integer'] == 0) 308
315 309 integer4 = self.integer_default.read(integer4_id, ['integer'])
316 integer4_id = self.integer_default.create(cursor, USER, {}, CONTEXT) 310 self.assert_(integer4['integer'] == 5)
317 self.assert_(integer4_id) 311
318 312 self.integer.write(integer1_id, {
319 integer4 = self.integer_default.read(cursor, USER, integer4_id, 313 'integer': 0,
320 ['integer'], CONTEXT) 314 })
321 self.assert_(integer4['integer'] == 5) 315 integer1 = self.integer.read(integer1_id, ['integer'])
322 316 self.assert_(integer1['integer'] == 0)
323 self.integer.write(cursor, USER, integer1_id, { 317
324 'integer': 0, 318 self.integer.write(integer2_id, {
325 }, CONTEXT) 319 'integer': 1,
326 integer1 = self.integer.read(cursor, USER, integer1_id, ['integer'], 320 })
327 CONTEXT) 321 integer2 = self.integer.read(integer2_id, ['integer'])
328 self.assert_(integer1['integer'] == 0) 322 self.assert_(integer2['integer'] == 1)
329 323
330 self.integer.write(cursor, USER, integer2_id, { 324 self.failUnlessRaises(Exception, self.integer.create, {
331 'integer': 1, 325 'integer': 'test',
332 }, CONTEXT) 326 })
333 integer2 = self.integer.read(cursor, USER, integer2_id, ['integer'], 327
334 CONTEXT) 328 self.failUnlessRaises(Exception, self.integer.write, integer1_id, {
335 self.assert_(integer2['integer'] == 1) 329 'integer': 'test',
336 330 })
337 self.failUnlessRaises(Exception, self.integer.create, cursor, USER, { 331
338 'integer': 'test', 332 integer5_id = self.integer_required.create({})
339 }, CONTEXT) 333 self.assert_(integer5_id)
340 334
341 self.failUnlessRaises(Exception, self.integer.write, cursor, USER, 335 integer5 = self.integer_required.read(integer5_id, ['integer'])
342 integer1_id, { 336 self.assert_(integer5['integer'] == 0)
343 'integer': 'test', 337
344 }, CONTEXT) 338 transaction.cursor.rollback()
345
346 integer5_id = self.integer_required.create(cursor, USER, {}, CONTEXT)
347 self.assert_(integer5_id)
348
349 integer5 = self.integer_required.read(cursor, USER, integer5_id,
350 ['integer'], CONTEXT)
351 self.assert_(integer5['integer'] == 0)
352
353 cursor.rollback()
354 cursor.close()
355 339
356 def test0030float(self): 340 def test0030float(self):
357 ''' 341 '''
358 Test Float. 342 Test Float.
359 ''' 343 '''
360 cursor = DB.cursor() 344 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
361 345 float1_id = self.float.create({
362 float1_id = self.float.create(cursor, USER, { 346 'float': 1.1,
363 'float': 1.1, 347 })
364 }, CONTEXT) 348 self.assert_(float1_id)
365 self.assert_(float1_id) 349
366 350 float1 = self.float.read(float1_id, ['float'])
367 float1 = self.float.read(cursor, USER, float1_id, ['float'], CONTEXT) 351 self.assert_(float1['float'] == 1.1)
368 self.assert_(float1['float'] == 1.1) 352
369 353 float_ids = self.float.search([
370 float_ids = self.float.search(cursor, USER, [ 354 ('float', '=', 1.1),
371 ('float', '=', 1.1), 355 ])
372 ], 0, None, None, CONTEXT) 356 self.assert_(float_ids == [float1_id])
373 self.assert_(float_ids == [float1_id]) 357
374 358 float_ids = self.float.search([
375 float_ids = self.float.search(cursor, USER, [ 359 ('float', '=', 0),
376 ('float', '=', 0), 360 ])
377 ], 0, None, None, CONTEXT) 361 self.assert_(float_ids == [])
378 self.assert_(float_ids == []) 362
379 363 float_ids = self.float.search([
380 float_ids = self.float.search(cursor, USER, [ 364 ('float', '!=', 1.1),
381 ('float', '!=', 1.1), 365 ])
382 ], 0, None, None, CONTEXT) 366 self.assert_(float_ids == [])
383 self.assert_(float_ids == []) 367
384 368 float_ids = self.float.search([
385 float_ids = self.float.search(cursor, USER, [ 369 ('float', '!=', 0),
386 ('float', '!=', 0), 370 ])
387 ], 0, None, None, CONTEXT) 371 self.assert_(float_ids == [float1_id])
388 self.assert_(float_ids == [float1_id]) 372
389 373 float_ids = self.float.search([
390 float_ids = self.float.search(cursor, USER, [ 374 ('float', 'in', [1.1]),
391 ('float', 'in', [1.1]), 375 ])
392 ], 0, None, None, CONTEXT) 376 self.assert_(float_ids == [float1_id])
393 self.assert_(float_ids == [float1_id]) 377
394 378 float_ids = self.float.search([
395 float_ids = self.float.search(cursor, USER, [ 379 ('float', 'in', [0]),
396 ('float', 'in', [0]), 380 ])
397 ], 0, None, None, CONTEXT) 381 self.assert_(float_ids == [])
398 self.assert_(float_ids == []) 382
399 383 float_ids = self.float.search([
400 float_ids = self.float.search(cursor, USER, [ 384 ('float', 'in', []),
401 ('float', 'in', []), 385 ])
402 ], 0, None, None, CONTEXT) 386 self.assert_(float_ids == [])
403 self.assert_(float_ids == []) 387
404 388 float_ids = self.float.search([
405 float_ids = self.float.search(cursor, USER, [ 389 ('float', 'not in', [1.1]),
406 ('float', 'not in', [1.1]), 390 ])
407 ], 0, None, None, CONTEXT) 391 self.assert_(float_ids == [])
408 self.assert_(float_ids == []) 392
409 393 float_ids = self.float.search([
410 float_ids = self.float.search(cursor, USER, [ 394 ('float', 'not in', [0]),
411 ('float', 'not in', [0]), 395 ])
412 ], 0, None, None, CONTEXT) 396 self.assert_(float_ids == [float1_id])
413 self.assert_(float_ids == [float1_id]) 397
414 398 float_ids = self.float.search([
415 float_ids = self.float.search(cursor, USER, [ 399 ('float', 'not in', []),
416 ('float', 'not in', []), 400 ])
417 ], 0, None, None, CONTEXT) 401 self.assert_(float_ids == [float1_id])
418 self.assert_(float_ids == [float1_id]) 402
419 403 float_ids = self.float.search([
420 float_ids = self.float.search(cursor, USER, [ 404 ('float', '<', 5),
421 ('float', '<', 5), 405 ])
422 ], 0, None, None, CONTEXT) 406 self.assert_(float_ids == [float1_id])
423 self.assert_(float_ids == [float1_id]) 407
424 408 float_ids = self.float.search([
425 float_ids = self.float.search(cursor, USER, [ 409 ('float', '<', -5),
426 ('float', '<', -5), 410 ])
427 ], 0, None, None, CONTEXT) 411 self.assert_(float_ids == [])
428 self.assert_(float_ids == []) 412
429 413 float_ids = self.float.search([
430 float_ids = self.float.search(cursor, USER, [ 414 ('float', '<', 1.1),
431 ('float', '<', 1.1), 415 ])
432 ], 0, None, None, CONTEXT) 416 self.assert_(float_ids == [])
433 self.assert_(float_ids == []) 417
434 418 float_ids = self.float.search([
435 float_ids = self.float.search(cursor, USER, [ 419 ('float', '<=', 5),
436 ('float', '<=', 5), 420 ])
437 ], 0, None, None, CONTEXT) 421 self.assert_(float_ids == [float1_id])
438 self.assert_(float_ids == [float1_id]) 422
439 423 float_ids = self.float.search([
440 float_ids = self.float.search(cursor, USER, [ 424 ('float', '<=', -5),
441 ('float', '<=', -5), 425 ])
442 ], 0, None, None, CONTEXT) 426 self.assert_(float_ids == [])
443 self.assert_(float_ids == []) 427
444 428 float_ids = self.float.search([
445 float_ids = self.float.search(cursor, USER, [ 429 ('float', '<=', 1.1),
446 ('float', '<=', 1.1), 430 ])
447 ], 0, None, None, CONTEXT) 431 self.assert_(float_ids == [float1_id])
448 self.assert_(float_ids == [float1_id]) 432
449 433 float_ids = self.float.search([
450 float_ids = self.float.search(cursor, USER, [ 434 ('float', '>', 5),
451 ('float', '>', 5), 435 ])
452 ], 0, None, None, CONTEXT) 436 self.assert_(float_ids == [])
453 self.assert_(float_ids == []) 437
454 438 float_ids = self.float.search([
455 float_ids = self.float.search(cursor, USER, [ 439 ('float', '>', -5),
456 ('float', '>', -5), 440 ])
457 ], 0, None, None, CONTEXT) 441 self.assert_(float_ids == [float1_id])
458 self.assert_(float_ids == [float1_id]) 442
459 443 float_ids = self.float.search([
460 float_ids = self.float.search(cursor, USER, [ 444 ('float', '>', 1.1),
461 ('float', '>', 1.1), 445 ])
462 ], 0, None, None, CONTEXT) 446 self.assert_(float_ids == [])
463 self.assert_(float_ids == []) 447
464 448 float_ids = self.float.search([
465 float_ids = self.float.search(cursor, USER, [ 449 ('float', '>=', 5),
466 ('float', '>=', 5), 450 ])
467 ], 0, None, None, CONTEXT) 451 self.assert_(float_ids == [])
468 self.assert_(float_ids == []) 452
469 453 float_ids = self.float.search([
470 float_ids = self.float.search(cursor, USER, [ 454 ('float', '>=', -5),
471 ('float', '>=', -5), 455 ])
472 ], 0, None, None, CONTEXT) 456 self.assert_(float_ids == [float1_id])
473 self.assert_(float_ids == [float1_id]) 457
474 458 float_ids = self.float.search([
475 float_ids = self.float.search(cursor, USER, [ 459 ('float', '>=', 1.1),
476 ('float', '>=', 1.1), 460 ])
477 ], 0, None, None, CONTEXT) 461 self.assert_(float_ids == [float1_id])
478 self.assert_(float_ids == [float1_id]) 462
479 463 float2_id = self.float.create({
480 float2_id = self.float.create(cursor, USER, { 464 'float': 0,
481 'float': 0, 465 })
482 }, CONTEXT) 466 self.assert_(float2_id)
483 self.assert_(float2_id) 467
484 468 float2 = self.float.read(float2_id, ['float'])
485 float2 = self.float.read(cursor, USER, float2_id, ['float'], CONTEXT) 469 self.assert_(float2['float'] == 0)
486 self.assert_(float2['float'] == 0) 470
487 471 float_ids = self.float.search([
488 float_ids = self.float.search(cursor, USER, [ 472 ('float', '=', 0),
489 ('float', '=', 0), 473 ])
490 ], 0, None, None, CONTEXT) 474 self.assert_(float_ids == [float2_id])
491 self.assert_(float_ids == [float2_id]) 475
492 476 float_ids = self.float.search([
493 float_ids = self.float.search(cursor, USER, [ 477 ('float', 'in', [0, 1.1]),
494 ('float', 'in', [0, 1.1]), 478 ])
495 ], 0, None, None, CONTEXT) 479 self.assert_(float_ids == [float1_id, float2_id])
496 self.assert_(float_ids == [float1_id, float2_id]) 480
497 481 float_ids = self.float.search([
498 float_ids = self.float.search(cursor, USER, [ 482 ('float', 'not in', [0, 1.1]),
499 ('float', 'not in', [0, 1.1]), 483 ])
500 ], 0, None, None, CONTEXT) 484 self.assert_(float_ids == [])
501 self.assert_(float_ids == []) 485
502 486 float3_id = self.float.create({})
503 float3_id = self.float.create(cursor, USER, {}, CONTEXT) 487 self.assert_(float3_id)
504 self.assert_(float3_id) 488
505 489 float3 = self.float.read(float3_id, ['float'])
506 float3 = self.float.read(cursor, USER, float3_id, ['float'], CONTEXT) 490 self.assert_(float3['float'] == 0)
507 self.assert_(float3['float'] == 0) 491
508 492 float4_id = self.float_default.create({})
509 float4_id = self.float_default.create(cursor, USER, {}, CONTEXT) 493 self.assert_(float4_id)
510 self.assert_(float4_id) 494
511 495 float4 = self.float_default.read(float4_id, ['float'])
512 float4 = self.float_default.read(cursor, USER, float4_id, ['float'], 496 self.assert_(float4['float'] == 5.5)
513 CONTEXT) 497
514 self.assert_(float4['float'] == 5.5) 498 self.float.write(float1_id, {
515 499 'float': 0,
516 self.float.write(cursor, USER, float1_id, { 500 })
517 'float': 0, 501 float1 = self.float.read(float1_id, ['float'])
518 }, CONTEXT) 502 self.assert_(float1['float'] == 0)
519 float1 = self.float.read(cursor, USER, float1_id, ['float'] , CONTEXT) 503
520 self.assert_(float1['float'] == 0) 504 self.float.write(float2_id, {
521 505 'float': 1.1,
522 self.float.write(cursor, USER, float2_id, { 506 })
523 'float': 1.1, 507 float2 = self.float.read(float2_id, ['float'])
524 }, CONTEXT) 508 self.assert_(float2['float'] == 1.1)
525 float2 = self.float.read(cursor, USER, float2_id, ['float'], CONTEXT) 509
526 self.assert_(float2['float'] == 1.1) 510 self.failUnlessRaises(Exception, self.float.create, {
527 511 'float': 'test',
528 self.failUnlessRaises(Exception, self.float.create, cursor, USER, { 512 })
529 'float': 'test', 513
530 }, CONTEXT) 514 self.failUnlessRaises(Exception, self.float.write, float1_id, {
531 515 'float': 'test',
532 self.failUnlessRaises(Exception, self.float.write, float1_id, cursor, 516 })
533 USER, { 517
534 'float': 'test', 518 float5_id = self.float_required.create({})
535 }, CONTEXT) 519 self.assert_(float5_id)
536 520
537 float5_id = self.float_required.create(cursor, USER, {}, CONTEXT) 521 float5 = self.float_required.read(float5_id, ['float'])
538 self.assert_(float5_id) 522 self.assert_(float5['float'] == 0)
539 523
540 float5 = self.float_required.read(cursor, USER, float5_id, ['float'], 524 float6_id = self.float_digits.create({
541 CONTEXT) 525 'digits': 1,
542 self.assert_(float5['float'] == 0) 526 'float': 1.1,
543 527 })
544 float6_id = self.float_digits.create(cursor, USER, { 528 self.assert_(float6_id)
545 'digits': 1, 529
546 'float': 1.1, 530 self.failUnlessRaises(Exception, self.float_digits.create, {
547 }, CONTEXT) 531 'digits': 1,
548 self.assert_(float6_id) 532 'float': 1.11,
549 533 })
550 self.failUnlessRaises(Exception, self.float_digits.create, cursor, 534
551 USER, { 535 self.failUnlessRaises(Exception, self.float_digits.write, float6_id, {
552 'digits': 1, 536 'float': 1.11,
553 'float': 1.11, 537 }, CONTEXT)
554 }, CONTEXT) 538
555 539 self.failUnlessRaises(Exception, self.float_digits.write, float6_id, {
556 self.failUnlessRaises(Exception, self.float_digits.write, cursor, 540 'digits': 0,
557 USER, float6_id, { 541 })
558 'float': 1.11, 542
559 }, CONTEXT) 543 float7_id = self.float.create({
560 544 'float': 0.123456789012345,
561 self.failUnlessRaises(Exception, self.float_digits.write, cursor, 545 })
562 USER, float6_id, { 546
563 'digits': 0, 547 float7 = self.float.read(float7_id, ['float'])
564 }, CONTEXT) 548 self.assert_(float7['float'] == 0.123456789012345)
565 549
566 float7_id = self.float.create(cursor, USER, { 550 transaction.cursor.rollback()
567 'float': 0.123456789012345,
568 }, CONTEXT)
569
570 float7 = self.float.read(cursor, USER, float7_id, ['float'], CONTEXT)
571 self.assert_(float7['float'] == 0.123456789012345)
572
573 cursor.rollback()
574 cursor.close()
575 551
576 def test0040numeric(self): 552 def test0040numeric(self):
577 ''' 553 '''
578 Test Numeric. 554 Test Numeric.
579 ''' 555 '''
580 cursor = DB.cursor() 556 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
581 557 numeric1_id = self.numeric.create({
582 numeric1_id = self.numeric.create(cursor, USER, { 558 'numeric': Decimal('1.1'),
583 'numeric': Decimal('1.1'), 559 })
584 }, CONTEXT) 560 self.assert_(numeric1_id)
585 self.assert_(numeric1_id) 561
586 562 numeric1 = self.numeric.read(numeric1_id, ['numeric'])
587 numeric1 = self.numeric.read(cursor, USER, numeric1_id, ['numeric'], 563 self.assert_(numeric1['numeric'] == Decimal('1.1'))
588 CONTEXT) 564
589 self.assert_(numeric1['numeric'] == Decimal('1.1')) 565 numeric_ids = self.numeric.search([
590 566 ('numeric', '=', Decimal('1.1')),
591 numeric_ids = self.numeric.search(cursor, USER, [ 567 ])
592 ('numeric', '=', Decimal('1.1')), 568 self.assert_(numeric_ids == [numeric1_id])
593 ], 0, None, None, CONTEXT) 569
594 self.assert_(numeric_ids == [numeric1_id]) 570 numeric_ids = self.numeric.search([
595 571 ('numeric', '=', Decimal('0')),
596 numeric_ids = self.numeric.search(cursor, USER, [ 572 ])
597 ('numeric', '=', Decimal('0')), 573 self.assert_(numeric_ids == [])
598 ], 0, None, None, CONTEXT) 574
599 self.assert_(numeric_ids == []) 575 numeric_ids = self.numeric.search([
600 576 ('numeric', '!=', Decimal('1.1')),
601 numeric_ids = self.numeric.search(cursor, USER, [ 577 ])
602 ('numeric', '!=', Decimal('1.1')), 578 self.assert_(numeric_ids == [])
603 ], 0, None, None, CONTEXT) 579
604 self.assert_(numeric_ids == []) 580 numeric_ids = self.numeric.search([
605 581 ('numeric', '!=', Decimal('0')),
606 numeric_ids = self.numeric.search(cursor, USER, [ 582 ])
607 ('numeric', '!=', Decimal('0')), 583 self.assert_(numeric_ids == [numeric1_id])
608 ], 0, None, None, CONTEXT) 584
609 self.assert_(numeric_ids == [numeric1_id]) 585 numeric_ids = self.numeric.search([
610 586 ('numeric', 'in', [Decimal('1.1')]),
611 numeric_ids = self.numeric.search(cursor, USER, [ 587 ])
612 ('numeric', 'in', [Decimal('1.1')]), 588 self.assert_(numeric_ids == [numeric1_id])
613 ], 0, None, None, CONTEXT) 589
614 self.assert_(numeric_ids == [numeric1_id]) 590 numeric_ids = self.numeric.search([
615 591 ('numeric', 'in', [Decimal('0')]),
616 numeric_ids = self.numeric.search(cursor, USER, [ 592 ])
617 ('numeric', 'in', [Decimal('0')]), 593 self.assert_(numeric_ids == [])
618 ], 0, None, None, CONTEXT) 594
619 self.assert_(numeric_ids == []) 595 numeric_ids = self.numeric.search([
620 596 ('numeric', 'in', []),
621 numeric_ids = self.numeric.search(cursor, USER, [ 597 ])
622 ('numeric', 'in', []), 598 self.assert_(numeric_ids == [])
623 ], 0, None, None, CONTEXT) 599
624 self.assert_(numeric_ids == []) 600 numeric_ids = self.numeric.search([
625 601 ('numeric', 'not in', [Decimal('1.1')]),
626 numeric_ids = self.numeric.search(cursor, USER, [ 602 ])
627 ('numeric', 'not in', [Decimal('1.1')]), 603 self.assert_(numeric_ids == [])
628 ], 0, None, None, CONTEXT) 604
629 self.assert_(numeric_ids == []) 605 numeric_ids = self.numeric.search([
630 606 ('numeric', 'not in', [Decimal('0')]),
631 numeric_ids = self.numeric.search(cursor, USER, [ 607 ])
632 ('numeric', 'not in', [Decimal('0')]), 608 self.assert_(numeric_ids == [numeric1_id])
633 ], 0, None, None, CONTEXT) 609
634 self.assert_(numeric_ids == [numeric1_id]) 610 numeric_ids = self.numeric.search([
635 611 ('numeric', 'not in', []),
636 numeric_ids = self.numeric.search(cursor, USER, [ 612 ])
637 ('numeric', 'not in', []), 613 self.assert_(numeric_ids == [numeric1_id])
638 ], 0, None, None, CONTEXT) 614
639 self.assert_(numeric_ids == [numeric1_id]) 615 numeric_ids = self.numeric.search([
640 616 ('numeric', '<', Decimal('5')),
641 numeric_ids = self.numeric.search(cursor, USER, [ 617 ])
642 ('numeric', '<', Decimal('5')), 618 self.assert_(numeric_ids == [numeric1_id])
643 ], 0, None, None, CONTEXT) 619
644 self.assert_(numeric_ids == [numeric1_id]) 620 numeric_ids = self.numeric.search([
645 621 ('numeric', '<', Decimal('-5')),
646 numeric_ids = self.numeric.search(cursor, USER, [ 622 ])
647 ('numeric', '<', Decimal('-5')), 623 self.assert_(numeric_ids == [])
648 ], 0, None, None, CONTEXT) 624
649 self.assert_(numeric_ids == []) 625 numeric_ids = self.numeric.search([
650 626 ('numeric', '<', Decimal('1.1')),
651 numeric_ids = self.numeric.search(cursor, USER, [ 627 ])
652 ('numeric', '<', Decimal('1.1')), 628 self.assert_(numeric_ids == [])
653 ], 0, None, None, CONTEXT) 629
654 self.assert_(numeric_ids == []) 630 numeric_ids = self.numeric.search([
655 631 ('numeric', '<=', Decimal('5')),
656 numeric_ids = self.numeric.search(cursor, USER, [ 632 ])
657 ('numeric', '<=', Decimal('5')), 633 self.assert_(numeric_ids == [numeric1_id])
658 ], 0, None, None, CONTEXT) 634
659 self.assert_(numeric_ids == [numeric1_id]) 635 numeric_ids = self.numeric.search([
660 636 ('numeric', '<=', Decimal('-5')),
661 numeric_ids = self.numeric.search(cursor, USER, [ 637 ])
662 ('numeric', '<=', Decimal('-5')), 638 self.assert_(numeric_ids == [])
663 ], 0, None, None, CONTEXT) 639
664 self.assert_(numeric_ids == []) 640 numeric_ids = self.numeric.search([
665 641 ('numeric', '<=', Decimal('1.1')),
666 numeric_ids = self.numeric.search(cursor, USER, [ 642 ])
667 ('numeric', '<=', Decimal('1.1')), 643 self.assert_(numeric_ids == [numeric1_id])
668 ], 0, None, None, CONTEXT) 644
669 self.assert_(numeric_ids == [numeric1_id]) 645 numeric_ids = self.numeric.search([
670 646 ('numeric', '>', Decimal('5')),
671 numeric_ids = self.numeric.search(cursor, USER, [ 647 ])
672 ('numeric', '>', Decimal('5')), 648 self.assert_(numeric_ids == [])
673 ], 0, None, None, CONTEXT) 649
674 self.assert_(numeric_ids == []) 650 numeric_ids = self.numeric.search([
675 651 ('numeric', '>', Decimal('-5')),
676 numeric_ids = self.numeric.search(cursor, USER, [ 652 ])
677 ('numeric', '>', Decimal('-5')), 653 self.assert_(numeric_ids == [numeric1_id])
678 ], 0, None, None, CONTEXT) 654
679 self.assert_(numeric_ids == [numeric1_id]) 655 numeric_ids = self.numeric.search([
680 656 ('numeric', '>', Decimal('1.1')),
681 numeric_ids = self.numeric.search(cursor, USER, [ 657 ])
682 ('numeric', '>', Decimal('1.1')), 658 self.assert_(numeric_ids == [])
683 ], 0, None, None, CONTEXT) 659
684 self.assert_(numeric_ids == []) 660 numeric_ids = self.numeric.search([
685 661 ('numeric', '>=', Decimal('5')),
686 numeric_ids = self.numeric.search(cursor, USER, [ 662 ])
687 ('numeric', '>=', Decimal('5')), 663 self.assert_(numeric_ids == [])
688 ], 0, None, None, CONTEXT) 664
689 self.assert_(numeric_ids == []) 665 numeric_ids = self.numeric.search([
690 666 ('numeric', '>=', Decimal('-5')),
691 numeric_ids = self.numeric.search(cursor, USER, [ 667 ])
692 ('numeric', '>=', Decimal('-5')), 668 self.assert_(numeric_ids == [numeric1_id])
693 ], 0, None, None, CONTEXT) 669
694 self.assert_(numeric_ids == [numeric1_id]) 670 numeric_ids = self.numeric.search([
695 671 ('numeric', '>=', Decimal('1.1')),
696 numeric_ids = self.numeric.search(cursor, USER, [ 672 ])
697 ('numeric', '>=', Decimal('1.1')), 673 self.assert_(numeric_ids == [numeric1_id])
698 ], 0, None, None, CONTEXT) 674
699 self.assert_(numeric_ids == [numeric1_id]) 675 numeric2_id = self.numeric.create({
700 676 'numeric': Decimal('0'),
701 numeric2_id = self.numeric.create(cursor, USER, { 677 })
702 'numeric': Decimal('0'), 678 self.assert_(numeric2_id)
703 }, CONTEXT) 679
704 self.assert_(numeric2_id) 680 numeric2 = self.numeric.read(numeric2_id, ['numeric'])
705 681 self.assert_(numeric2['numeric'] == Decimal('0'))
706 numeric2 = self.numeric.read(cursor, USER, numeric2_id, ['numeric'], 682
707 CONTEXT) 683 numeric_ids = self.numeric.search([
708 self.assert_(numeric2['numeric'] == Decimal('0')) 684 ('numeric', '=', Decimal('0')),
709 685 ])
710 numeric_ids = self.numeric.search(cursor, USER, [ 686 self.assert_(numeric_ids == [numeric2_id])
711 ('numeric', '=', Decimal('0')), 687
712 ], 0, None, None, CONTEXT) 688 numeric_ids = self.numeric.search([
713 self.assert_(numeric_ids == [numeric2_id]) 689 ('numeric', 'in', [Decimal('0'), Decimal('1.1')]),
714 690 ])
715 numeric_ids = self.numeric.search(cursor, USER, [ 691 self.assert_(numeric_ids == [numeric1_id, numeric2_id])
716 ('numeric', 'in', [Decimal('0'), Decimal('1.1')]), 692
717 ], 0, None, None, CONTEXT) 693 numeric_ids = self.numeric.search([
718 self.assert_(numeric_ids == [numeric1_id, numeric2_id]) 694 ('numeric', 'not in', [Decimal('0'), Decimal('1.1')]),
719 695 ])
720 numeric_ids = self.numeric.search(cursor, USER, [ 696 self.assert_(numeric_ids == [])
721 ('numeric', 'not in', [Decimal('0'), Decimal('1.1')]), 697
722 ], 0, None, None, CONTEXT) 698 numeric3_id = self.numeric.create({})
723 self.assert_(numeric_ids == []) 699 self.assert_(numeric3_id)
724 700
725 numeric3_id = self.numeric.create(cursor, USER, {}, CONTEXT) 701 numeric3 = self.numeric.read(numeric3_id, ['numeric'])
726 self.assert_(numeric3_id) 702 self.assert_(numeric3['numeric'] == Decimal('0'))
727 703
728 numeric3 = self.numeric.read(cursor, USER, numeric3_id, ['numeric'], 704 numeric4_id = self.numeric_default.create({})
729 CONTEXT) 705 self.assert_(numeric4_id)
730 self.assert_(numeric3['numeric'] == Decimal('0')) 706
731 707 numeric4 = self.numeric_default.read(numeric4_id, ['numeric'])
732 numeric4_id = self.numeric_default.create(cursor, USER, {}, CONTEXT) 708 self.assert_(numeric4['numeric'] == Decimal('5.5'))
733 self.assert_(numeric4_id) 709
734 710 self.numeric.write(numeric1_id, {
735 numeric4 = self.numeric_default.read(cursor, USER, numeric4_id, 711 'numeric': Decimal('0'),
736 ['numeric'], CONTEXT) 712 })
737 self.assert_(numeric4['numeric'] == Decimal('5.5')) 713 numeric1 = self.numeric.read(numeric1_id, ['numeric'])
738 714 self.assert_(numeric1['numeric'] == Decimal('0'))
739 self.numeric.write(cursor, USER, numeric1_id, { 715
740 'numeric': Decimal('0'), 716 self.numeric.write(numeric2_id, {
741 }, CONTEXT) 717 'numeric': Decimal('1.1'),
742 numeric1 = self.numeric.read(cursor, USER, numeric1_id, ['numeric'] , 718 })
743 CONTEXT) 719 numeric2 = self.numeric.read(numeric2_id, ['numeric'])
744 self.assert_(numeric1['numeric'] == Decimal('0')) 720 self.assert_(numeric2['numeric'] == Decimal('1.1'))
745 721
746 self.numeric.write(cursor, USER, numeric2_id, { 722 self.failUnlessRaises(Exception, self.numeric.create, {
747 'numeric': Decimal('1.1'), 723 'numeric': 'test',
748 }, CONTEXT) 724 })
749 numeric2 = self.numeric.read(cursor, USER, numeric2_id, ['numeric'], 725
750 CONTEXT) 726 self.failUnlessRaises(Exception, self.numeric.write, numeric1_id, {
751 self.assert_(numeric2['numeric'] == Decimal('1.1')) 727 'numeric': 'test',
752 728 })
753 self.failUnlessRaises(Exception, self.numeric.create, cursor, USER, { 729
754 'numeric': 'test', 730 numeric5_id = self.numeric_required.create({})
755 }, CONTEXT) 731 self.assert_(numeric5_id)
756 732
757 self.failUnlessRaises(Exception, self.numeric.write, numeric1_id, 733 numeric5 = self.numeric_required.read(numeric5_id, ['numeric'])
758 cursor, USER, { 734 self.assert_(numeric5['numeric'] == Decimal('0'))
759 'numeric': 'test', 735
760 }, CONTEXT) 736 numeric6_id = self.numeric_digits.create({
761 737 'digits': 1,
762 numeric5_id = self.numeric_required.create(cursor, USER, {}, CONTEXT) 738 'numeric': Decimal('1.1'),
763 self.assert_(numeric5_id) 739 })
764 740 self.assert_(numeric6_id)
765 numeric5 = self.numeric_required.read(cursor, USER, numeric5_id, 741
766 ['numeric'], CONTEXT) 742 self.failUnlessRaises(Exception, self.numeric_digits.create, {
767 self.assert_(numeric5['numeric'] == Decimal('0')) 743 'digits': 1,
768 744 'numeric': Decimal('1.11'),
769 numeric6_id = self.numeric_digits.create(cursor, USER, { 745 })
770 'digits': 1, 746
771 'numeric': Decimal('1.1'), 747 self.failUnlessRaises(Exception, self.numeric_digits.write,
772 }, CONTEXT) 748 numeric6_id, {
773 self.assert_(numeric6_id) 749 'numeric': Decimal('1.11'),
774 750 })
775 self.failUnlessRaises(Exception, self.numeric_digits.create, cursor, 751
776 USER, { 752 self.failUnlessRaises(Exception, self.numeric_digits.write,
777 'digits': 1, 753 numeric6_id, {
778 'numeric': Decimal('1.11'), 754 'digits': 0,
779 }, CONTEXT) 755 })
780 756
781 self.failUnlessRaises(Exception, self.numeric_digits.write, cursor, 757 numeric7_id = self.numeric.create({
782 USER, numeric6_id, { 758 'numeric': Decimal('0.1234567890123456789'),
783 'numeric': Decimal('1.11'), 759 })
784 }, CONTEXT) 760
785 761 numeric7 = self.numeric.read(numeric7_id, ['numeric'])
786 self.failUnlessRaises(Exception, self.numeric_digits.write, cursor, 762 self.assert_(numeric7['numeric'] ==
787 USER, numeric6_id, { 763 Decimal('0.1234567890123456789'))
788 'digits': 0, 764
789 }, CONTEXT) 765 transaction.cursor.rollback()
790
791 numeric7_id = self.numeric.create(cursor, USER, {
792 'numeric': Decimal('0.1234567890123456789'),
793 }, CONTEXT)
794
795 numeric7 = self.numeric.read(cursor, USER, numeric7_id, ['numeric'],
796 CONTEXT)
797 self.assert_(numeric7['numeric'] ==
798 Decimal('0.1234567890123456789'))
799
800 cursor.rollback()
801 cursor.close()
802 766
803 def test0050char(self): 767 def test0050char(self):
804 ''' 768 '''
805 Test Char. 769 Test Char.
806 ''' 770 '''
807 cursor = DB.cursor() 771 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
808 772 for char in (self.char, self.char_translate):
809 for char in (self.char, self.char_translate): 773 char1_id = char.create({
810 char1_id = char.create(cursor, USER, { 774 'char': 'Test',
775 })
776 self.assert_(char1_id)
777
778 char1 = char.read(char1_id, ['char'])
779 self.assert_(char1['char'] == 'Test')
780
781 char_ids = char.search([
782 ('char', '=', 'Test'),
783 ])
784 self.assert_(char_ids == [char1_id])
785
786 char_ids = char.search([
787 ('char', '=', 'Foo'),
788 ])
789 self.assert_(char_ids == [])
790
791 char_ids = char.search([
792 ('char', '=', False),
793 ])
794 self.assert_(char_ids == [])
795
796 char_ids = char.search([
797 ('char', '!=', 'Test'),
798 ])
799 self.assert_(char_ids == [])
800
801 char_ids = char.search([
802 ('char', '!=', 'Foo'),
803 ])
804 self.assert_(char_ids == [char1_id])
805
806 char_ids = char.search([
807 ('char', '!=', False),
808 ])
809 self.assert_(char_ids == [char1_id])
810
811 char_ids = char.search([
812 ('char', 'in', ['Test']),
813 ])
814 self.assert_(char_ids == [char1_id])
815
816 char_ids = char.search([
817 ('char', 'in', ['Foo']),
818 ])
819 self.assert_(char_ids == [])
820
821 char_ids = char.search([
822 ('char', 'in', [False]),
823 ])
824 self.assert_(char_ids == [])
825
826 char_ids = char.search([
827 ('char', 'in', []),
828 ])
829 self.assert_(char_ids == [])
830
831 char_ids = char.search([
832 ('char', 'not in', ['Test']),
833 ])
834 self.assert_(char_ids == [])
835
836 char_ids = char.search([
837 ('char', 'not in', ['Foo']),
838 ])
839 self.assert_(char_ids == [char1_id])
840
841 char_ids = char.search([
842 ('char', 'not in', [False]),
843 ])
844 self.assert_(char_ids == [char1_id])
845
846 char_ids = char.search([
847 ('char', 'not in', []),
848 ])
849 self.assert_(char_ids == [char1_id])
850
851 char_ids = char.search([
852 ('char', 'like', 'Test'),
853 ])
854 self.assert_(char_ids == [char1_id])
855
856 char_ids = char.search([
857 ('char', 'like', 'T%'),
858 ])
859 self.assert_(char_ids == [char1_id])
860
861 char_ids = char.search([
862 ('char', 'like', 'Foo'),
863 ])
864 self.assert_(char_ids == [])
865
866 char_ids = char.search([
867 ('char', 'like', 'F%'),
868 ])
869 self.assert_(char_ids == [])
870
871 char_ids = char.search([
872 ('char', 'ilike', 'test'),
873 ])
874 self.assert_(char_ids == [char1_id])
875
876 char_ids = char.search([
877 ('char', 'ilike', 't%'),
878 ])
879 self.assert_(char_ids == [char1_id])
880
881 char_ids = char.search([
882 ('char', 'ilike', 'foo'),
883 ])
884 self.assert_(char_ids == [])
885
886 char_ids = char.search([
887 ('char', 'ilike', 'f%'),
888 ])
889 self.assert_(char_ids == [])
890
891 char_ids = char.search([
892 ('char', 'not like', 'Test'),
893 ])
894 self.assert_(char_ids == [])
895
896 char_ids = char.search([
897 ('char', 'not like', 'T%'),
898 ])
899 self.assert_(char_ids == [])
900
901 char_ids = char.search([
902 ('char', 'not like', 'Foo'),
903 ])
904 self.assert_(char_ids == [char1_id])
905
906 char_ids = char.search([
907 ('char', 'not like', 'F%'),
908 ])
909 self.assert_(char_ids == [char1_id])
910
911 char_ids = char.search([
912 ('char', 'not ilike', 'test'),
913 ])
914 self.assert_(char_ids == [])
915
916 char_ids = char.search([
917 ('char', 'not ilike', 't%'),
918 ])
919 self.assert_(char_ids == [])
920
921 char_ids = char.search([
922 ('char', 'not ilike', 'foo'),
923 ])
924 self.assert_(char_ids == [char1_id])
925
926 char_ids = char.search([
927 ('char', 'not ilike', 'f%'),
928 ])
929 self.assert_(char_ids == [char1_id])
930
931 char2_id = char.create({
932 'char': False,
933 })
934 self.assert_(char2_id)
935
936 char2 = char.read(char2_id, ['char'])
937 self.assert_(char2['char'] == None)
938
939 char_ids = char.search([
940 ('char', '=', False),
941 ])
942 self.assert_(char_ids == [char2_id])
943
944 char_ids = char.search([
945 ('char', 'in', [False, 'Test']),
946 ])
947 self.assert_(char_ids == [char1_id, char2_id])
948
949 char_ids = char.search([
950 ('char', 'not in', [False, 'Test']),
951 ])
952 self.assert_(char_ids == [])
953
954 char3_id = self.char.create({})
955 self.assert_(char3_id)
956
957 char3 = self.char.read(char3_id, ['char'])
958 self.assert_(char3['char'] == None)
959
960 char4_id = self.char_default.create({})
961 self.assert_(char4_id)
962
963 char4 = self.char_default.read(char4_id, ['char'])
964 self.assert_(char4['char'] == 'Test')
965
966 self.char.write(char1_id, {
967 'char': False,
968 })
969 char1 = self.char.read(char1_id, ['char'])
970 self.assert_(char1['char'] == None)
971
972 self.char.write(char2_id, {
811 'char': 'Test', 973 'char': 'Test',
812 }, CONTEXT) 974 })
813 self.assert_(char1_id) 975 char2 = self.char.read(char2_id, ['char'])
814 976 self.assert_(char2['char'] == 'Test')
815 char1 = char.read(cursor, USER, char1_id, ['char'], CONTEXT) 977
816 self.assert_(char1['char'] == 'Test') 978 self.failUnlessRaises(Exception, self.char_required.create, {})
817 979 transaction.cursor.rollback()
818 char_ids = char.search(cursor, USER, [ 980
819 ('char', '=', 'Test'), 981 char5_id = self.char_required.create({
820 ], 0, None, None, CONTEXT) 982 'char': 'Test',
821 self.assert_(char_ids == [char1_id]) 983 })
822 984 self.assert_(char5_id)
823 char_ids = char.search(cursor, USER, [ 985
824 ('char', '=', 'Foo'), 986 char6_id = self.char_size.create({
825 ], 0, None, None, CONTEXT) 987 'char': 'Test',
826 self.assert_(char_ids == []) 988 })
827 989 self.assert_(char6_id)
828 char_ids = char.search(cursor, USER, [ 990
829 ('char', '=', False), 991 self.failUnlessRaises(Exception, self.char_size.create, {
830 ], 0, None, None, CONTEXT) 992 'char': 'foobar',
831 self.assert_(char_ids == []) 993 })
832 994
833 char_ids = char.search(cursor, USER, [ 995 self.failUnlessRaises(Exception, self.char_size.write, char6_id, {
834 ('char', '!=', 'Test'), 996 'char': 'foobar',
835 ], 0, None, None, CONTEXT) 997 })
836 self.assert_(char_ids == []) 998 transaction.cursor.rollback()
837 999
838 char_ids = char.search(cursor, USER, [ 1000 char7_id = self.char.create({
839 ('char', '!=', 'Foo'), 1001 'char': u'é',
840 ], 0, None, None, CONTEXT) 1002 })
841 self.assert_(char_ids == [char1_id]) 1003 self.assert_(char7_id)
842 1004
843 char_ids = char.search(cursor, USER, [ 1005 char7 = self.char.read(char7_id, ['char'])
844 ('char', '!=', False), 1006 self.assert_(char7['char'] == u'é')
845 ], 0, None, None, CONTEXT) 1007
846 self.assert_(char_ids == [char1_id]) 1008 char_ids = self.char.search([
847 1009 ('char', '=', u'é'),
848 char_ids = char.search(cursor, USER, [ 1010 ])
849 ('char', 'in', ['Test']), 1011 self.assert_(char_ids == [char7_id])
850 ], 0, None, None, CONTEXT) 1012
851 self.assert_(char_ids == [char1_id]) 1013 self.char.write(char7_id, {
852 1014 'char': 'é',
853 char_ids = char.search(cursor, USER, [ 1015 })
854 ('char', 'in', ['Foo']), 1016 char7 = self.char.read(char7_id, ['char'])
855 ], 0, None, None, CONTEXT) 1017 self.assert_(char7['char'] == u'é')
856 self.assert_(char_ids == []) 1018
857 1019 char_ids = self.char.search([
858 char_ids = char.search(cursor, USER, [ 1020 ('char', '=', 'é'),
859 ('char', 'in', [False]), 1021 ])
860 ], 0, None, None, CONTEXT) 1022 self.assert_(char_ids == [char7_id])
861 self.assert_(char_ids == []) 1023
862 1024 transaction.cursor.rollback()
863 char_ids = char.search(cursor, USER, [
864 ('char', 'in', []),
865 ], 0, None, None, CONTEXT)
866 self.assert_(char_ids == [])
867
868 char_ids = char.search(cursor, USER, [
869 ('char', 'not in', ['Test']),
870 ], 0, None, None, CONTEXT)
871 self.assert_(char_ids == [])
872
873 char_ids = char.search(cursor, USER, [
874 ('char', 'not in', ['Foo']),
875 ], 0, None, None, CONTEXT)
876 self.assert_(char_ids == [char1_id])
877
878 char_ids = char.search(cursor, USER, [
879 ('char', 'not in', [False]),
880 ], 0, None, None, CONTEXT)
881 self.assert_(char_ids == [char1_id])
882
883 char_ids = char.search(cursor, USER, [
884 ('char', 'not in', []),
885 ], 0, None, None, CONTEXT)
886 self.assert_(char_ids == [char1_id])
887
888 char_ids = char.search(cursor, USER, [
889 ('char', 'like', 'Test'),
890 ], 0, None, None, CONTEXT)
891 self.assert_(char_ids == [char1_id])
892
893 char_ids = char.search(cursor, USER, [
894 ('char', 'like', 'T%'),
895 ], 0, None, None, CONTEXT)
896 self.assert_(char_ids == [char1_id])
897
898 char_ids = char.search(cursor, USER, [
899 ('char', 'like', 'Foo'),
900 ], 0, None, None, CONTEXT)
901 self.assert_(char_ids == [])
902
903 char_ids = char.search(cursor, USER, [
904 ('char', 'like', 'F%'),
905 ], 0, None, None, CONTEXT)
906 self.assert_(char_ids == [])
907
908 char_ids = char.search(cursor, USER, [
909 ('char', 'ilike', 'test'),
910 ], 0, None, None, CONTEXT)
911 self.assert_(char_ids == [char1_id])
912
913 char_ids = char.search(cursor, USER, [
914 ('char', 'ilike', 't%'),
915 ], 0, None, None, CONTEXT)
916 self.assert_(char_ids == [char1_id])
917
918 char_ids = char.search(cursor, USER, [
919 ('char', 'ilike', 'foo'),
920 ], 0, None, None, CONTEXT)
921 self.assert_(char_ids == [])
922
923 char_ids = char.search(cursor, USER, [
924 ('char', 'ilike', 'f%'),
925 ], 0, None, None, CONTEXT)
926 self.assert_(char_ids == [])
927
928 char_ids = char.search(cursor, USER, [
929 ('char', 'not like', 'Test'),
930 ], 0, None, None, CONTEXT)
931 self.assert_(char_ids == [])
932
933 char_ids = char.search(cursor, USER, [
934 ('char', 'not like', 'T%'),
935 ], 0, None, None, CONTEXT)
936 self.assert_(char_ids == [])
937
938 char_ids = char.search(cursor, USER, [
939 ('char', 'not like', 'Foo'),
940 ], 0, None, None, CONTEXT)
941 self.assert_(char_ids == [char1_id])
942
943 char_ids = char.search(cursor, USER, [
944 ('char', 'not like', 'F%'),
945 ], 0, None, None, CONTEXT)
946 self.assert_(char_ids == [char1_id])
947
948 char_ids = char.search(cursor, USER, [
949 ('char', 'not ilike', 'test'),
950 ], 0, None, None, CONTEXT)
951 self.assert_(char_ids == [])
952
953 char_ids = char.search(cursor, USER, [
954 ('char', 'not ilike', 't%'),
955 ], 0, None, None, CONTEXT)
956 self.assert_(char_ids == [])
957
958 char_ids = char.search(cursor, USER, [
959 ('char', 'not ilike', 'foo'),
960 ], 0, None, None, CONTEXT)
961 self.assert_(char_ids == [char1_id])
962
963 char_ids = char.search(cursor, USER, [
964 ('char', 'not ilike', 'f%'),
965 ], 0, None, None, CONTEXT)
966 self.assert_(char_ids == [char1_id])
967
968 char2_id = char.create(cursor, USER, {
969 'char': False,
970 }, CONTEXT)
971 self.assert_(char2_id)
972
973 char2 = char.read(cursor, USER, char2_id, ['char'], CONTEXT)
974 self.assert_(char2['char'] == None)
975
976 char_ids = char.search(cursor, USER, [
977 ('char', '=', False),
978 ], 0, None, None, CONTEXT)
979 self.assert_(char_ids == [char2_id])
980
981 char_ids = char.search(cursor, USER, [
982 ('char', 'in', [False, 'Test']),
983 ], 0, None, None, CONTEXT)
984 self.assert_(char_ids == [char1_id, char2_id])
985
986 char_ids = char.search(cursor, USER, [
987 ('char', 'not in', [False, 'Test']),
988 ], 0, None, None, CONTEXT)
989 self.assert_(char_ids == [])
990
991 char3_id = self.char.create(cursor, USER, {}, CONTEXT)
992 self.assert_(char3_id)
993
994 char3 = self.char.read(cursor, USER, char3_id, ['char'], CONTEXT)
995 self.assert_(char3['char'] == None)
996
997 char4_id = self.char_default.create(cursor, USER, {}, CONTEXT)
998 self.assert_(char4_id)
999
1000 char4 = self.char_default.read(cursor, USER, char4_id, ['char'],
1001 CONTEXT)
1002 self.assert_(char4['char'] == 'Test')
1003
1004 self.char.write(cursor, USER, char1_id, {
1005 'char': False,
1006 }, CONTEXT)
1007 char1 = self.char.read(cursor, USER, char1_id, ['char'], CONTEXT)
1008 self.assert_(char1['char'] == None)
1009
1010 self.char.write(cursor, USER, char2_id, {
1011 'char': 'Test',
1012 }, CONTEXT)
1013 char2 = self.char.read(cursor, USER, char2_id, ['char'], CONTEXT)
1014 self.assert_(char2['char'] == 'Test')
1015
1016 self.failUnlessRaises(Exception, self.char_required.create, cursor,
1017 USER, {}, CONTEXT)
1018 cursor.rollback()
1019
1020 char5_id = self.char_required.create(cursor, USER, {
1021 'char': 'Test',
1022 }, CONTEXT)
1023 self.assert_(char5_id)
1024
1025 char6_id = self.char_size.create(cursor, USER, {
1026 'char': 'Test',
1027 }, CONTEXT)
1028 self.assert_(char6_id)
1029
1030 self.failUnlessRaises(Exception, self.char_size.create, cursor, USER, {
1031 'char': 'foobar',
1032 }, CONTEXT)
1033
1034 self.failUnlessRaises(Exception, self.char_size.write, cursor, USER,
1035 char6_id, {
1036 'char': 'foobar',
1037 }, CONTEXT)
1038 cursor.rollback()
1039
1040 char7_id = self.char.create(cursor, USER, {
1041 'char': u'é',
1042 }, CONTEXT)
1043 self.assert_(char7_id)
1044
1045 char7 = self.char.read(cursor, USER, char7_id, ['char'], CONTEXT)
1046 self.assert_(char7['char'] == u'é')
1047
1048 char_ids = self.char.search(cursor, USER, [
1049 ('char', '=', u'é'),
1050 ], 0, None, None, CONTEXT)
1051 self.assert_(char_ids == [char7_id])
1052
1053 self.char.write(cursor, USER, char7_id, {
1054 'char': 'é',
1055 }, CONTEXT)
1056 char7 = self.char.read(cursor, USER, char7_id, ['char'], CONTEXT)
1057 self.assert_(char7['char'] == u'é')
1058
1059 char_ids = self.char.search(cursor, USER, [
1060 ('char', '=', 'é'),
1061 ], 0, None, None, CONTEXT)
1062 self.assert_(char_ids == [char7_id])
1063
1064 cursor.rollback()
1065 cursor.close()
1066 1025
1067 def test0060text(self): 1026 def test0060text(self):
1068 ''' 1027 '''
1069 Test Text. 1028 Test Text.
1070 ''' 1029 '''
1071 cursor = DB.cursor() 1030 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
1072 1031 for text in (self.text, self.text_translate):
1073 for text in (self.text, self.text_translate): 1032 text1_id = text.create({
1074 text1_id = text.create(cursor, USER, { 1033 'text': 'Test',
1034 })
1035 self.assert_(text1_id)
1036
1037 text1 = text.read(text1_id, ['text'])
1038 self.assert_(text1['text'] == 'Test')
1039
1040 text_ids = text.search([
1041 ('text', '=', 'Test'),
1042 ])
1043 self.assert_(text_ids == [text1_id])
1044
1045 text_ids = text.search([
1046 ('text', '=', 'Foo'),
1047 ])
1048 self.assert_(text_ids == [])
1049
1050 text_ids = text.search([
1051 ('text', '=', False),
1052 ])
1053 self.assert_(text_ids == [])
1054
1055 text_ids = text.search([
1056 ('text', '!=', 'Test'),
1057 ])
1058 self.assert_(text_ids == [])
1059
1060 text_ids = text.search([
1061 ('text', '!=', 'Foo'),
1062 ])
1063 self.assert_(text_ids == [text1_id])
1064
1065 text_ids = text.search([
1066 ('text', '!=', False),
1067 ])
1068 self.assert_(text_ids == [text1_id])
1069
1070 text_ids = text.search([
1071 ('text', 'in', ['Test']),
1072 ])
1073 self.assert_(text_ids == [text1_id])
1074
1075 text_ids = text.search([
1076 ('text', 'in', ['Foo']),
1077 ])
1078 self.assert_(text_ids == [])
1079
1080 text_ids = text.search([
1081 ('text', 'in', [False]),
1082 ])
1083 self.assert_(text_ids == [])
1084
1085 text_ids = text.search([
1086 ('text', 'in', []),
1087 ])
1088 self.assert_(text_ids == [])
1089
1090 text_ids = text.search([
1091 ('text', 'not in', ['Test']),
1092 ])
1093 self.assert_(text_ids == [])
1094
1095 text_ids = text.search([
1096 ('text', 'not in', ['Foo']),
1097 ])
1098 self.assert_(text_ids == [text1_id])
1099
1100 text_ids = text.search([
1101 ('text', 'not in', [False]),
1102 ])
1103 self.assert_(text_ids == [text1_id])
1104
1105 text_ids = text.search([
1106 ('text', 'not in', []),
1107 ])
1108 self.assert_(text_ids == [text1_id])
1109
1110 text_ids = text.search([
1111 ('text', 'like', 'Test'),
1112 ])
1113 self.assert_(text_ids == [text1_id])
1114
1115 text_ids = text.search([
1116 ('text', 'like', 'T%'),
1117 ])
1118 self.assert_(text_ids == [text1_id])
1119
1120 text_ids = text.search([
1121 ('text', 'like', 'Foo'),
1122 ])
1123 self.assert_(text_ids == [])
1124
1125 text_ids = text.search([
1126 ('text', 'like', 'F%'),
1127 ])
1128 self.assert_(text_ids == [])
1129
1130 text_ids = text.search([
1131 ('text', 'ilike', 'test'),
1132 ])
1133 self.assert_(text_ids == [text1_id])
1134
1135 text_ids = text.search([
1136 ('text', 'ilike', 't%'),
1137 ])
1138 self.assert_(text_ids == [text1_id])
1139
1140 text_ids = text.search([
1141 ('text', 'ilike', 'foo'),
1142 ])
1143 self.assert_(text_ids == [])
1144
1145 text_ids = text.search([
1146 ('text', 'ilike', 'f%'),
1147 ])
1148 self.assert_(text_ids == [])
1149
1150 text_ids = text.search([
1151 ('text', 'not like', 'Test'),
1152 ])
1153 self.assert_(text_ids == [])
1154
1155 text_ids = text.search([
1156 ('text', 'not like', 'T%'),
1157 ])
1158 self.assert_(text_ids == [])
1159
1160 text_ids = text.search([
1161 ('text', 'not like', 'Foo'),
1162 ])
1163 self.assert_(text_ids == [text1_id])
1164
1165 text_ids = text.search([
1166 ('text', 'not like', 'F%'),
1167 ])
1168 self.assert_(text_ids == [text1_id])
1169
1170 text_ids = text.search([
1171 ('text', 'not ilike', 'test'),
1172 ])
1173 self.assert_(text_ids == [])
1174
1175 text_ids = text.search([
1176 ('text', 'not ilike', 't%'),
1177 ])
1178 self.assert_(text_ids == [])
1179
1180 text_ids = text.search([
1181 ('text', 'not ilike', 'foo'),
1182 ])
1183 self.assert_(text_ids == [text1_id])
1184
1185 text_ids = text.search([
1186 ('text', 'not ilike', 'f%'),
1187 ])
1188 self.assert_(text_ids == [text1_id])
1189
1190 text2_id = text.create({
1191 'text': False,
1192 })
1193 self.assert_(text2_id)
1194
1195 text2 = text.read(text2_id, ['text'])
1196 self.assert_(text2['text'] == None)
1197
1198 text_ids = text.search([
1199 ('text', '=', False),
1200 ])
1201 self.assert_(text_ids == [text2_id])
1202
1203 text_ids = text.search([
1204 ('text', 'in', [False, 'Test']),
1205 ])
1206 self.assert_(text_ids == [text1_id, text2_id])
1207
1208 text_ids = text.search([
1209 ('text', 'not in', [False, 'Test']),
1210 ])
1211 self.assert_(text_ids == [])
1212
1213 text3_id = self.text.create({})
1214 self.assert_(text3_id)
1215
1216 text3 = self.text.read(text3_id, ['text'])
1217 self.assert_(text3['text'] == None)
1218
1219 text4_id = self.text_default.create({})
1220 self.assert_(text4_id)
1221
1222 text4 = self.text_default.read(text4_id, ['text'])
1223 self.assert_(text4['text'] == 'Test')
1224
1225 self.text.write(text1_id, {
1226 'text': False,
1227 })
1228 text1 = self.text.read(text1_id, ['text'])
1229 self.assert_(text1['text'] == None)
1230
1231 self.text.write(text2_id, {
1075 'text': 'Test', 1232 'text': 'Test',
1076 }, CONTEXT) 1233 })
1077 self.assert_(text1_id) 1234 text2 = self.text.read(text2_id, ['text'])
1078 1235 self.assert_(text2['text'] == 'Test')
1079 text1 = text.read(cursor, USER, text1_id, ['text'], CONTEXT) 1236
1080 self.assert_(text1['text'] == 'Test') 1237 self.failUnlessRaises(Exception, self.text_required.create, {})
1081 1238 transaction.cursor.rollback()
1082 text_ids = text.search(cursor, USER, [ 1239
1083 ('text', '=', 'Test'), 1240 text5_id = self.text_required.create({
1084 ], 0, None, None, CONTEXT) 1241 'text': 'Test',
1085 self.assert_(text_ids == [text1_id]) 1242 })
1086 1243 self.assert_(text5_id)
1087 text_ids = text.search(cursor, USER, [ 1244
1088 ('text', '=', 'Foo'), 1245 text6_id = self.text_size.create({
1089 ], 0, None, None, CONTEXT) 1246 'text': 'Test',
1090 self.assert_(text_ids == []) 1247 })
1091 1248 self.assert_(text6_id)
1092 text_ids = text.search(cursor, USER, [ 1249
1093 ('text', '=', False), 1250 self.failUnlessRaises(Exception, self.text_size.create, {
1094 ], 0, None, None, CONTEXT) 1251 'text': 'foobar',
1095 self.assert_(text_ids == []) 1252 })
1096 1253
1097 text_ids = text.search(cursor, USER, [ 1254 self.failUnlessRaises(Exception, self.text_size.write, text6_id, {
1098 ('text', '!=', 'Test'), 1255 'text': 'foobar',
1099 ], 0, None, None, CONTEXT) 1256 })
1100 self.assert_(text_ids == []) 1257
1101 1258 text7_id = self.text.create({
1102 text_ids = text.search(cursor, USER, [ 1259 'text': 'Foo\nBar',
1103 ('text', '!=', 'Foo'), 1260 })
1104 ], 0, None, None, CONTEXT) 1261 self.assert_(text7_id)
1105 self.assert_(text_ids == [text1_id]) 1262
1106 1263 text8_id = self.text.create({
1107 text_ids = text.search(cursor, USER, [ 1264 'text': u'é',
1108 ('text', '!=', False), 1265 })
1109 ], 0, None, None, CONTEXT) 1266 self.assert_(text8_id)
1110 self.assert_(text_ids == [text1_id]) 1267
1111 1268 text8 = self.text.read(text8_id, ['text'])
1112 text_ids = text.search(cursor, USER, [ 1269 self.assert_(text8['text'] == u'é')
1113 ('text', 'in', ['Test']), 1270
1114 ], 0, None, None, CONTEXT) 1271 text_ids = self.text.search([
1115 self.assert_(text_ids == [text1_id]) 1272 ('text', '=', u'é'),
1116 1273 ])
1117 text_ids = text.search(cursor, USER, [ 1274 self.assert_(text_ids == [text8_id])
1118 ('text', 'in', ['Foo']), 1275
1119 ], 0, None, None, CONTEXT) 1276 self.text.write(text8_id, {
1120 self.assert_(text_ids == []) 1277 'text': 'é',
1121 1278 })
1122 text_ids = text.search(cursor, USER, [ 1279 text8 = self.text.read(text8_id, ['text'])
1123 ('text', 'in', [False]), 1280 self.assert_(text8['text'] == u'é')
1124 ], 0, None, None, CONTEXT) 1281
1125 self.assert_(text_ids == []) 1282 text_ids = self.text.search([
1126 1283 ('text', '=', 'é'),
1127 text_ids = text.search(cursor, USER, [ 1284 ])
1128 ('text', 'in', []), 1285 self.assert_(text_ids == [text8_id])
1129 ], 0, None, None, CONTEXT) 1286
1130 self.assert_(text_ids == []) 1287 transaction.cursor.rollback()
1131
1132 text_ids = text.search(cursor, USER, [
1133 ('text', 'not in', ['Test']),
1134 ], 0, None, None, CONTEXT)
1135 self.assert_(text_ids == [])
1136
1137 text_ids = text.search(cursor, USER, [
1138 ('text', 'not in', ['Foo']),
1139 ], 0, None, None, CONTEXT)
1140 self.assert_(text_ids == [text1_id])
1141
1142 text_ids = text.search(cursor, USER, [
1143 ('text', 'not in', [False]),
1144 ], 0, None, None, CONTEXT)
1145 self.assert_(text_ids == [text1_id])
1146
1147 text_ids = text.search(cursor, USER, [
1148 ('text', 'not in', []),
1149 ], 0, None, None, CONTEXT)
1150 self.assert_(text_ids == [text1_id])
1151
1152 text_ids = text.search(cursor, USER, [
1153 ('text', 'like', 'Test'),
1154 ], 0, None, None, CONTEXT)
1155 self.assert_(text_ids == [text1_id])
1156
1157 text_ids = text.search(cursor, USER, [
1158 ('text', 'like', 'T%'),
1159 ], 0, None, None, CONTEXT)
1160 self.assert_(text_ids == [text1_id])
1161
1162 text_ids = text.search(cursor, USER, [
1163 ('text', 'like', 'Foo'),
1164 ], 0, None, None, CONTEXT)
1165 self.assert_(text_ids == [])
1166
1167 text_ids = text.search(cursor, USER, [
1168 ('text', 'like', 'F%'),
1169 ], 0, None, None, CONTEXT)
1170 self.assert_(text_ids == [])
1171
1172 text_ids = text.search(cursor, USER, [
1173 ('text', 'ilike', 'test'),
1174 ], 0, None, None, CONTEXT)
1175 self.assert_(text_ids == [text1_id])
1176
1177 text_ids = text.search(cursor, USER, [
1178 ('text', 'ilike', 't%'),
1179 ], 0, None, None, CONTEXT)
1180 self.assert_(text_ids == [text1_id])
1181
1182 text_ids = text.search(cursor, USER, [
1183 ('text', 'ilike', 'foo'),
1184 ], 0, None, None, CONTEXT)
1185 self.assert_(text_ids == [])
1186
1187 text_ids = text.search(cursor, USER, [
1188 ('text', 'ilike', 'f%'),
1189 ], 0, None, None, CONTEXT)
1190 self.assert_(text_ids == [])
1191
1192 text_ids = text.search(cursor, USER, [
1193 ('text', 'not like', 'Test'),
1194 ], 0, None, None, CONTEXT)
1195 self.assert_(text_ids == [])
1196
1197 text_ids = text.search(cursor, USER, [
1198 ('text', 'not like', 'T%'),
1199 ], 0, None, None, CONTEXT)
1200 self.assert_(text_ids == [])
1201
1202 text_ids = text.search(cursor, USER, [
1203 ('text', 'not like', 'Foo'),
1204 ], 0, None, None, CONTEXT)
1205 self.assert_(text_ids == [text1_id])
1206
1207 text_ids = text.search(cursor, USER, [
1208 ('text', 'not like', 'F%'),
1209 ], 0, None, None, CONTEXT)
1210 self.assert_(text_ids == [text1_id])
1211
1212 text_ids = text.search(cursor, USER, [
1213 ('text', 'not ilike', 'test'),
1214 ], 0, None, None, CONTEXT)
1215 self.assert_(text_ids == [])
1216
1217 text_ids = text.search(cursor, USER, [
1218 ('text', 'not ilike', 't%'),
1219 ], 0, None, None, CONTEXT)
1220 self.assert_(text_ids == [])
1221
1222 text_ids = text.search(cursor, USER, [
1223 ('text', 'not ilike', 'foo'),
1224 ], 0, None, None, CONTEXT)
1225 self.assert_(text_ids == [text1_id])
1226
1227 text_ids = text.search(cursor, USER, [
1228 ('text', 'not ilike', 'f%'),
1229 ], 0, None, None, CONTEXT)
1230 self.assert_(text_ids == [text1_id])
1231
1232 text2_id = text.create(cursor, USER, {
1233 'text': False,
1234 }, CONTEXT)
1235 self.assert_(text2_id)
1236
1237 text2 = text.read(cursor, USER, text2_id, ['text'], CONTEXT)
1238 self.assert_(text2['text'] == None)
1239
1240 text_ids = text.search(cursor, USER, [
1241 ('text', '=', False),
1242 ], 0, None, None, CONTEXT)
1243 self.assert_(text_ids == [text2_id])
1244
1245 text_ids = text.search(cursor, USER, [
1246 ('text', 'in', [False, 'Test']),
1247 ], 0, None, None, CONTEXT)
1248 self.assert_(text_ids == [text1_id, text2_id])
1249
1250 text_ids = text.search(cursor, USER, [
1251 ('text', 'not in', [False, 'Test']),
1252 ], 0, None, None, CONTEXT)
1253 self.assert_(text_ids == [])
1254
1255 text3_id = self.text.create(cursor, USER, {}, CONTEXT)
1256 self.assert_(text3_id)
1257
1258 text3 = self.text.read(cursor, USER, text3_id, ['text'], CONTEXT)
1259 self.assert_(text3['text'] == None)
1260
1261 text4_id = self.text_default.create(cursor, USER, {}, CONTEXT)
1262 self.assert_(text4_id)
1263
1264 text4 = self.text_default.read(cursor, USER, text4_id, ['text'],
1265 CONTEXT)
1266 self.assert_(text4['text'] == 'Test')
1267
1268 self.text.write(cursor, USER, text1_id, {
1269 'text': False,
1270 }, CONTEXT)
1271 text1 = self.text.read(cursor, USER, text1_id, ['text'], CONTEXT)
1272 self.assert_(text1['text'] == None)
1273
1274 self.text.write(cursor, USER, text2_id, {
1275 'text': 'Test',
1276 }, CONTEXT)
1277 text2 = self.text.read(cursor, USER, text2_id, ['text'], CONTEXT)
1278 self.assert_(text2['text'] == 'Test')
1279
1280 self.failUnlessRaises(Exception, self.text_required.create, cursor,
1281 USER, {}, CONTEXT)
1282 cursor.rollback()
1283
1284 text5_id = self.text_required.create(cursor, USER, {
1285 'text': 'Test',
1286 }, CONTEXT)
1287 self.assert_(text5_id)
1288
1289 text6_id = self.text_size.create(cursor, USER, {
1290 'text': 'Test',
1291 }, CONTEXT)
1292 self.assert_(text6_id)
1293
1294 self.failUnlessRaises(Exception, self.text_size.create, cursor, USER, {
1295 'text': 'foobar',
1296 }, CONTEXT)
1297
1298 self.failUnlessRaises(Exception, self.text_size.write, cursor, USER,
1299 text6_id, {
1300 'text': 'foobar',
1301 }, CONTEXT)
1302
1303 text7_id = self.text.create(cursor, USER, {
1304 'text': 'Foo\nBar',
1305 }, CONTEXT)
1306 self.assert_(text7_id)
1307
1308 text8_id = self.text.create(cursor, USER, {
1309 'text': u'é',
1310 }, CONTEXT)
1311 self.assert_(text8_id)
1312
1313 text8 = self.text.read(cursor, USER, text8_id, ['text'], CONTEXT)
1314 self.assert_(text8['text'] == u'é')
1315
1316 text_ids = self.text.search(cursor, USER, [
1317 ('text', '=', u'é'),
1318 ], 0, None, None, CONTEXT)
1319 self.assert_(text_ids == [text8_id])
1320
1321 self.text.write(cursor, USER, text8_id, {
1322 'text': 'é',
1323 }, CONTEXT)
1324 text8 = self.text.read(cursor, USER, text8_id, ['text'], CONTEXT)
1325 self.assert_(text8['text'] == u'é')
1326
1327 text_ids = self.text.search(cursor, USER, [
1328 ('text', '=', 'é'),
1329 ], 0, None, None, CONTEXT)
1330 self.assert_(text_ids == [text8_id])
1331
1332 cursor.rollback()
1333 cursor.close()
1334 1288
1335 def test0070sha(self): 1289 def test0070sha(self):
1336 ''' 1290 '''
1337 Test Sha. 1291 Test Sha.
1338 ''' 1292 '''
1339 cursor = DB.cursor() 1293 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
1340 1294 sha1_id = self.sha.create({
1341 sha1_id = self.sha.create(cursor, USER, { 1295 'sha': 'Test',
1342 'sha': 'Test', 1296 })
1343 }, CONTEXT) 1297 self.assert_(sha1_id)
1344 self.assert_(sha1_id) 1298
1345 1299 sha1 = self.sha.read(sha1_id, ['sha'])
1346 sha1 = self.sha.read(cursor, USER, sha1_id, ['sha'], CONTEXT) 1300 self.assert_(sha1['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1f a')
1347 self.assert_(sha1['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') 1301
1348 1302 sha_ids = self.sha.search([
1349 sha_ids = self.sha.search(cursor, USER, [ 1303 ('sha', '=', 'Test'),
1350 ('sha', '=', 'Test'), 1304 ])
1351 ], 0, None, None, CONTEXT) 1305 self.assert_(sha_ids == [sha1_id])
1352 self.assert_(sha_ids == [sha1_id]) 1306
1353 1307 sha_ids = self.sha.search([
1354 sha_ids = self.sha.search(cursor, USER, [ 1308 ('sha', '=', 'Foo'),
1355 ('sha', '=', 'Foo'), 1309 ])
1356 ], 0, None, None, CONTEXT) 1310 self.assert_(sha_ids == [])
1357 self.assert_(sha_ids == []) 1311
1358 1312 sha_ids = self.sha.search([
1359 sha_ids = self.sha.search(cursor, USER, [ 1313 ('sha', '=', False),
1360 ('sha', '=', False), 1314 ])
1361 ], 0, None, None, CONTEXT) 1315 self.assert_(sha_ids == [])
1362 self.assert_(sha_ids == []) 1316
1363 1317 sha_ids = self.sha.search([
1364 sha_ids = self.sha.search(cursor, USER, [ 1318 ('sha', '!=', 'Test'),
1365 ('sha', '!=', 'Test'), 1319 ])
1366 ], 0, None, None, CONTEXT) 1320 self.assert_(sha_ids == [])
1367 self.assert_(sha_ids == []) 1321
1368 1322 sha_ids = self.sha.search([
1369 sha_ids = self.sha.search(cursor, USER, [ 1323 ('sha', '!=', 'Foo'),
1370 ('sha', '!=', 'Foo'), 1324 ])
1371 ], 0, None, None, CONTEXT) 1325 self.assert_(sha_ids == [sha1_id])
1372 self.assert_(sha_ids == [sha1_id]) 1326
1373 1327 sha_ids = self.sha.search([
1374 sha_ids = self.sha.search(cursor, USER, [ 1328 ('sha', '!=', False),
1375 ('sha', '!=', False), 1329 ])
1376 ], 0, None, None, CONTEXT) 1330 self.assert_(sha_ids == [sha1_id])
1377 self.assert_(sha_ids == [sha1_id]) 1331
1378 1332 sha_ids = self.sha.search([
1379 sha_ids = self.sha.search(cursor, USER, [ 1333 ('sha', 'in', ['Test']),
1380 ('sha', 'in', ['Test']), 1334 ])
1381 ], 0, None, None, CONTEXT) 1335 self.assert_(sha_ids == [sha1_id])
1382 self.assert_(sha_ids == [sha1_id]) 1336
1383 1337 sha_ids = self.sha.search([
1384 sha_ids = self.sha.search(cursor, USER, [ 1338 ('sha', 'in', ['Foo']),
1385 ('sha', 'in', ['Foo']), 1339 ])
1386 ], 0, None, None, CONTEXT) 1340 self.assert_(sha_ids == [])
1387 self.assert_(sha_ids == []) 1341
1388 1342 sha_ids = self.sha.search([
1389 sha_ids = self.sha.search(cursor, USER, [ 1343 ('sha', 'in', [False]),
1390 ('sha', 'in', [False]), 1344 ])
1391 ], 0, None, None, CONTEXT) 1345 self.assert_(sha_ids == [])
1392 self.assert_(sha_ids == []) 1346
1393 1347 sha_ids = self.sha.search([
1394 sha_ids = self.sha.search(cursor, USER, [ 1348 ('sha', 'in', []),
1395 ('sha', 'in', []), 1349 ])
1396 ], 0, None, None, CONTEXT) 1350 self.assert_(sha_ids == [])
1397 self.assert_(sha_ids == []) 1351
1398 1352 sha_ids = self.sha.search([
1399 sha_ids = self.sha.search(cursor, USER, [ 1353 ('sha', 'not in', ['Test']),
1400 ('sha', 'not in', ['Test']), 1354 ])
1401 ], 0, None, None, CONTEXT) 1355 self.assert_(sha_ids == [])
1402 self.assert_(sha_ids == []) 1356
1403 1357 sha_ids = self.sha.search([
1404 sha_ids = self.sha.search(cursor, USER, [ 1358 ('sha', 'not in', ['Foo']),
1405 ('sha', 'not in', ['Foo']), 1359 ])
1406 ], 0, None, None, CONTEXT) 1360 self.assert_(sha_ids == [sha1_id])
1407 self.assert_(sha_ids == [sha1_id]) 1361
1408 1362 sha_ids = self.sha.search([
1409 sha_ids = self.sha.search(cursor, USER, [ 1363 ('sha', 'not in', [False]),
1410 ('sha', 'not in', [False]), 1364 ])
1411 ], 0, None, None, CONTEXT) 1365 self.assert_(sha_ids == [sha1_id])
1412 self.assert_(sha_ids == [sha1_id]) 1366
1413 1367 sha_ids = self.sha.search([
1414 sha_ids = self.sha.search(cursor, USER, [ 1368 ('sha', 'not in', []),
1415 ('sha', 'not in', []), 1369 ])
1416 ], 0, None, None, CONTEXT) 1370 self.assert_(sha_ids == [sha1_id])
1417 self.assert_(sha_ids == [sha1_id]) 1371
1418 1372 sha_ids = self.sha.search([
1419 sha_ids = self.sha.search(cursor, USER, [ 1373 ('sha', 'like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'),
1420 ('sha', 'like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), 1374 ])
1421 ], 0, None, None, CONTEXT) 1375 self.assert_(sha_ids == [sha1_id])
1422 self.assert_(sha_ids == [sha1_id]) 1376
1423 1377 sha_ids = self.sha.search([
1424 sha_ids = self.sha.search(cursor, USER, [ 1378 ('sha', 'like', '640a%'),
1425 ('sha', 'like', '640a%'), 1379 ])
1426 ], 0, None, None, CONTEXT) 1380 self.assert_(sha_ids == [sha1_id])
1427 self.assert_(sha_ids == [sha1_id]) 1381
1428 1382 sha_ids = self.sha.search([
1429 sha_ids = self.sha.search(cursor, USER, [ 1383 ('sha', 'like', 'Foo'),
1430 ('sha', 'like', 'Foo'), 1384 ])
1431 ], 0, None, None, CONTEXT) 1385 self.assert_(sha_ids == [])
1432 self.assert_(sha_ids == []) 1386
1433 1387 sha_ids = self.sha.search([
1434 sha_ids = self.sha.search(cursor, USER, [ 1388 ('sha', 'like', 'F%'),
1435 ('sha', 'like', 'F%'), 1389 ])
1436 ], 0, None, None, CONTEXT) 1390 self.assert_(sha_ids == [])
1437 self.assert_(sha_ids == []) 1391
1438 1392 sha_ids = self.sha.search([
1439 sha_ids = self.sha.search(cursor, USER, [ 1393 ('sha', 'ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'),
1440 ('sha', 'ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), 1394 ])
1441 ], 0, None, None, CONTEXT) 1395 self.assert_(sha_ids == [sha1_id])
1442 self.assert_(sha_ids == [sha1_id]) 1396
1443 1397 sha_ids = self.sha.search([
1444 sha_ids = self.sha.search(cursor, USER, [ 1398 ('sha', 'ilike', '640A%'),
1445 ('sha', 'ilike', '640A%'), 1399 ])
1446 ], 0, None, None, CONTEXT) 1400 self.assert_(sha_ids == [sha1_id])
1447 self.assert_(sha_ids == [sha1_id]) 1401
1448 1402 sha_ids = self.sha.search([
1449 sha_ids = self.sha.search(cursor, USER, [ 1403 ('sha', 'ilike', 'foo'),
1450 ('sha', 'ilike', 'foo'), 1404 ])
1451 ], 0, None, None, CONTEXT) 1405 self.assert_(sha_ids == [])
1452 self.assert_(sha_ids == []) 1406
1453 1407 sha_ids = self.sha.search([
1454 sha_ids = self.sha.search(cursor, USER, [ 1408 ('sha', 'ilike', 'f%'),
1455 ('sha', 'ilike', 'f%'), 1409 ])
1456 ], 0, None, None, CONTEXT) 1410 self.assert_(sha_ids == [])
1457 self.assert_(sha_ids == []) 1411
1458 1412 sha_ids = self.sha.search([
1459 sha_ids = self.sha.search(cursor, USER, [ 1413 ('sha', 'not like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'),
1460 ('sha', 'not like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), 1414 ])
1461 ], 0, None, None, CONTEXT) 1415 self.assert_(sha_ids == [])
1462 self.assert_(sha_ids == []) 1416
1463 1417 sha_ids = self.sha.search([
1464 sha_ids = self.sha.search(cursor, USER, [ 1418 ('sha', 'not like', '640a%'),
1465 ('sha', 'not like', '640a%'), 1419 ])
1466 ], 0, None, None, CONTEXT) 1420 self.assert_(sha_ids == [])
1467 self.assert_(sha_ids == []) 1421
1468 1422 sha_ids = self.sha.search([
1469 sha_ids = self.sha.search(cursor, USER, [ 1423 ('sha', 'not like', 'Foo'),
1470 ('sha', 'not like', 'Foo'), 1424 ])
1471 ], 0, None, None, CONTEXT) 1425 self.assert_(sha_ids == [sha1_id])
1472 self.assert_(sha_ids == [sha1_id]) 1426
1473 1427 sha_ids = self.sha.search([
1474 sha_ids = self.sha.search(cursor, USER, [ 1428 ('sha', 'not like', 'F%'),
1475 ('sha', 'not like', 'F%'), 1429 ])
1476 ], 0, None, None, CONTEXT) 1430 self.assert_(sha_ids == [sha1_id])
1477 self.assert_(sha_ids == [sha1_id]) 1431
1478 1432 sha_ids = self.sha.search([
1479 sha_ids = self.sha.search(cursor, USER, [ 1433 ('sha', 'not ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA') ,
1480 ('sha', 'not ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), 1434 ])
1481 ], 0, None, None, CONTEXT) 1435 self.assert_(sha_ids == [])
1482 self.assert_(sha_ids == []) 1436
1483 1437 sha_ids = self.sha.search([
1484 sha_ids = self.sha.search(cursor, USER, [ 1438 ('sha', 'not ilike', '640A%'),
1485 ('sha', 'not ilike', '640A%'), 1439 ])
1486 ], 0, None, None, CONTEXT) 1440 self.assert_(sha_ids == [])
1487 self.assert_(sha_ids == []) 1441
1488 1442 sha_ids = self.sha.search([
1489 sha_ids = self.sha.search(cursor, USER, [ 1443 ('sha', 'not ilike', 'foo'),
1490 ('sha', 'not ilike', 'foo'), 1444 ])
1491 ], 0, None, None, CONTEXT) 1445 self.assert_(sha_ids == [sha1_id])
1492 self.assert_(sha_ids == [sha1_id]) 1446
1493 1447 sha_ids = self.sha.search([
1494 sha_ids = self.sha.search(cursor, USER, [ 1448 ('sha', 'not ilike', 'f%'),
1495 ('sha', 'not ilike', 'f%'), 1449 ])
1496 ], 0, None, None, CONTEXT) 1450 self.assert_(sha_ids == [sha1_id])
1497 self.assert_(sha_ids == [sha1_id]) 1451
1498 1452 sha2_id = self.sha.create({
1499 sha2_id = self.sha.create(cursor, USER, { 1453 'sha': False,
1500 'sha': False, 1454 })
1501 }, CONTEXT) 1455 self.assert_(sha2_id)
1502 self.assert_(sha2_id) 1456
1503 1457 sha2 = self.sha.read(sha2_id, ['sha'])
1504 sha2 = self.sha.read(cursor, USER, sha2_id, ['sha'], CONTEXT) 1458 self.assert_(sha2['sha'] == None)
1505 self.assert_(sha2['sha'] == None) 1459
1506 1460 sha_ids = self.sha.search([
1507 sha_ids = self.sha.search(cursor, USER, [ 1461 ('sha', '=', False),
1508 ('sha', '=', False), 1462 ])
1509 ], 0, None, None, CONTEXT) 1463 self.assert_(sha_ids == [sha2_id])
1510 self.assert_(sha_ids == [sha2_id]) 1464
1511 1465 sha_ids = self.sha.search([
1512 sha_ids = self.sha.search(cursor, USER, [ 1466 ('sha', 'in', [False, 'Test']),
1513 ('sha', 'in', [False, 'Test']), 1467 ])
1514 ], 0, None, None, CONTEXT) 1468 self.assert_(sha_ids == [sha1_id, sha2_id])
1515 self.assert_(sha_ids == [sha1_id, sha2_id]) 1469
1516 1470 sha_ids = self.sha.search([
1517 sha_ids = self.sha.search(cursor, USER, [ 1471 ('sha', 'not in', [False, 'Test']),
1518 ('sha', 'not in', [False, 'Test']), 1472 ])
1519 ], 0, None, None, CONTEXT) 1473 self.assert_(sha_ids == [])
1520 self.assert_(sha_ids == []) 1474
1521 1475 sha3_id = self.sha.create({})
1522 sha3_id = self.sha.create(cursor, USER, {}, CONTEXT) 1476 self.assert_(sha3_id)
1523 self.assert_(sha3_id) 1477
1524 1478 sha3 = self.sha.read(sha3_id, ['sha'])
1525 sha3 = self.sha.read(cursor, USER, sha3_id, ['sha'], CONTEXT) 1479 self.assert_(sha3['sha'] == None)
1526 self.assert_(sha3['sha'] == None) 1480
1527 1481 sha4_id = self.sha_default.create({})
1528 sha4_id = self.sha_default.create(cursor, USER, {}, CONTEXT) 1482 self.assert_(sha4_id)
1529 self.assert_(sha4_id) 1483
1530 1484 sha4 = self.sha_default.read(sha4_id, ['sha'])
1531 sha4 = self.sha_default.read(cursor, USER, sha4_id, ['sha'], CONTEXT) 1485 self.assert_(sha4['sha'] == 'ba79baeb9f10896a46ae74715271b7f586e7464 0')
1532 self.assert_(sha4['sha'] == 'ba79baeb9f10896a46ae74715271b7f586e74640') 1486
1533 1487 self.sha.write(sha1_id, {
1534 self.sha.write(cursor, USER, sha1_id, { 1488 'sha': False,
1535 'sha': False, 1489 })
1536 }, CONTEXT) 1490 sha1 = self.sha.read(sha1_id, ['sha'])
1537 sha1 = self.sha.read(cursor, USER, sha1_id, ['sha'], CONTEXT) 1491 self.assert_(sha1['sha'] == None)
1538 self.assert_(sha1['sha'] == None) 1492
1539 1493 self.sha.write(sha2_id, {
1540 self.sha.write(cursor, USER, sha2_id, { 1494 'sha': 'Test',
1541 'sha': 'Test', 1495 })
1542 }, CONTEXT) 1496 sha2 = self.sha.read(sha2_id, ['sha'])
1543 sha2 = self.sha.read(cursor, USER, sha2_id, ['sha'], CONTEXT) 1497 self.assert_(sha2['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1f a')
1544 self.assert_(sha2['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') 1498
1545 1499 self.failUnlessRaises(Exception, self.sha_required.create, {})
1546 self.failUnlessRaises(Exception, self.sha_required.create, cursor, 1500 transaction.cursor.rollback()
1547 USER, {}, CONTEXT) 1501
1548 cursor.rollback() 1502 sha5_id = self.sha_required.create({
1549 1503 'sha': 'Test',
1550 sha5_id = self.sha_required.create(cursor, USER, { 1504 })
1551 'sha': 'Test', 1505 self.assert_(sha5_id)
1552 }, CONTEXT) 1506
1553 self.assert_(sha5_id) 1507 sha6_id = self.sha.create({
1554 1508 'sha': u'é',
1555 sha6_id = self.sha.create(cursor, USER, { 1509 })
1556 'sha': u'é', 1510 self.assert_(sha6_id)
1557 }, CONTEXT) 1511
1558 self.assert_(sha6_id) 1512 sha6 = self.sha.read(sha6_id, ['sha'])
1559 1513 self.assert_(sha6['sha'] ==
1560 sha6 = self.sha.read(cursor, USER, sha6_id, ['sha'], CONTEXT) 1514 u'bf15be717ac1b080b4f1c456692825891ff5073d')
1561 self.assert_(sha6['sha'] == 1515
1562 u'bf15be717ac1b080b4f1c456692825891ff5073d') 1516 sha_ids = self.sha.search([
1563 1517 ('sha', '=', u'é'),
1564 sha_ids = self.sha.search(cursor, USER, [ 1518 ])
1565 ('sha', '=', u'é'), 1519 self.assert_(sha_ids == [sha6_id])
1566 ], 0, None, None, CONTEXT) 1520
1567 self.assert_(sha_ids == [sha6_id]) 1521 self.sha.write(sha6_id, {
1568 1522 'sha': 'é',
1569 self.sha.write(cursor, USER, sha6_id, { 1523 })
1570 'sha': 'é', 1524 sha6 = self.sha.read(sha6_id, ['sha'])
1571 }, CONTEXT) 1525 self.assert_(sha6['sha'] ==
1572 sha6 = self.sha.read(cursor, USER, sha6_id, ['sha'], CONTEXT) 1526 u'bf15be717ac1b080b4f1c456692825891ff5073d')
1573 self.assert_(sha6['sha'] == 1527
1574 u'bf15be717ac1b080b4f1c456692825891ff5073d') 1528 sha_ids = self.sha.search([
1575 1529 ('sha', '=', 'é'),
1576 sha_ids = self.sha.search(cursor, USER, [ 1530 ])
1577 ('sha', '=', 'é'), 1531 self.assert_(sha_ids == [sha6_id])
1578 ], 0, None, None, CONTEXT) 1532
1579 self.assert_(sha_ids == [sha6_id]) 1533 transaction.cursor.rollback()
1580
1581 cursor.rollback()
1582 cursor.close()
1583 1534
1584 def test0080date(self): 1535 def test0080date(self):
1585 ''' 1536 '''
1586 Test Date. 1537 Test Date.
1587 ''' 1538 '''
1588 cursor = DB.cursor() 1539 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
1589 1540 today = datetime.date(2009, 1, 1)
1590 today = datetime.date(2009, 1, 1) 1541 tomorrow = today + datetime.timedelta(1)
1591 tomorrow = today + datetime.timedelta(1) 1542 yesterday = today - datetime.timedelta(1)
1592 yesterday = today - datetime.timedelta(1) 1543 default_date = datetime.date(2000, 1, 1)
1593 default_date = datetime.date(2000, 1, 1) 1544
1594 1545 date1_id = self.date.create({
1595 date1_id = self.date.create(cursor, USER, { 1546 'date': today,
1596 'date': today, 1547 })
1597 }, CONTEXT) 1548 self.assert_(date1_id)
1598 self.assert_(date1_id) 1549
1599 1550 date1 = self.date.read(date1_id, ['date'])
1600 date1 = self.date.read(cursor, USER, date1_id, ['date'], CONTEXT) 1551 self.assert_(date1['date'] == today)
1601 self.assert_(date1['date'] == today) 1552
1602 1553 date_ids = self.date.search([
1603 date_ids = self.date.search(cursor, USER, [ 1554 ('date', '=', today),
1604 ('date', '=', today), 1555 ])
1605 ], 0, None, None, CONTEXT) 1556 self.assert_(date_ids == [date1_id])
1606 self.assert_(date_ids == [date1_id]) 1557
1607 1558 date_ids = self.date.search([
1608 date_ids = self.date.search(cursor, USER, [ 1559 ('date', '=', tomorrow),
1609 ('date', '=', tomorrow), 1560 ])
1610 ], 0, None, None, CONTEXT) 1561 self.assert_(date_ids == [])
1611 self.assert_(date_ids == []) 1562
1612 1563 date_ids = self.date.search([
1613 date_ids = self.date.search(cursor, USER, [ 1564 ('date', '=', False),
1614 ('date', '=', False), 1565 ])
1615 ], 0, None, None, CONTEXT) 1566 self.assert_(date_ids == [])
1616 self.assert_(date_ids == []) 1567
1617 1568 date_ids = self.date.search([
1618 date_ids = self.date.search(cursor, USER, [ 1569 ('date', '!=', today),
1619 ('date', '!=', today), 1570 ])
1620 ], 0, None, None, CONTEXT) 1571 self.assert_(date_ids == [])
1621 self.assert_(date_ids == []) 1572
1622 1573 date_ids = self.date.search([
1623 date_ids = self.date.search(cursor, USER, [ 1574 ('date', '!=', tomorrow),
1624 ('date', '!=', tomorrow), 1575 ])
1625 ], 0, None, None, CONTEXT) 1576 self.assert_(date_ids == [date1_id])
1626 self.assert_(date_ids == [date1_id]) 1577
1627 1578 date_ids = self.date.search([
1628 date_ids = self.date.search(cursor, USER, [ 1579 ('date', '!=', False),
1629 ('date', '!=', False), 1580 ])
1630 ], 0, None, None, CONTEXT) 1581 self.assert_(date_ids == [date1_id])
1631 self.assert_(date_ids == [date1_id]) 1582
1632 1583 date_ids = self.date.search([
1633 date_ids = self.date.search(cursor, USER, [ 1584 ('date', 'in', [today]),
1634 ('date', 'in', [today]), 1585 ])
1635 ], 0, None, None, CONTEXT) 1586 self.assert_(date_ids == [date1_id])
1636 self.assert_(date_ids == [date1_id]) 1587
1637 1588 date_ids = self.date.search([
1638 date_ids = self.date.search(cursor, USER, [ 1589 ('date', 'in', [tomorrow]),
1639 ('date', 'in', [tomorrow]), 1590 ])
1640 ], 0, None, None, CONTEXT) 1591 self.assert_(date_ids == [])
1641 self.assert_(date_ids == []) 1592
1642 1593 date_ids = self.date.search([
1643 date_ids = self.date.search(cursor, USER, [ 1594 ('date', 'in', [False]),
1644 ('date', 'in', [False]), 1595 ])
1645 ], 0, None, None, CONTEXT) 1596 self.assert_(date_ids == [])
1646 self.assert_(date_ids == []) 1597
1647 1598 date_ids = self.date.search([
1648 date_ids = self.date.search(cursor, USER, [ 1599 ('date', 'in', []),
1649 ('date', 'in', []), 1600 ])
1650 ], 0, None, None, CONTEXT) 1601 self.assert_(date_ids == [])
1651 self.assert_(date_ids == []) 1602
1652 1603 date_ids = self.date.search([
1653 date_ids = self.date.search(cursor, USER, [ 1604 ('date', 'not in', [today]),
1654 ('date', 'not in', [today]), 1605 ])
1655 ], 0, None, None, CONTEXT) 1606 self.assert_(date_ids == [])
1656 self.assert_(date_ids == []) 1607
1657 1608 date_ids = self.date.search([
1658 date_ids = self.date.search(cursor, USER, [ 1609 ('date', 'not in', [tomorrow]),
1659 ('date', 'not in', [tomorrow]), 1610 ])
1660 ], 0, None, None, CONTEXT) 1611 self.assert_(date_ids == [date1_id])
1661 self.assert_(date_ids == [date1_id]) 1612
1662 1613 date_ids = self.date.search([
1663 date_ids = self.date.search(cursor, USER, [ 1614 ('date', 'not in', [False]),
1664 ('date', 'not in', [False]), 1615 ])
1665 ], 0, None, None, CONTEXT) 1616 self.assert_(date_ids == [date1_id])
1666 self.assert_(date_ids == [date1_id]) 1617
1667 1618 date_ids = self.date.search([
1668 date_ids = self.date.search(cursor, USER, [ 1619 ('date', 'not in', []),
1669 ('date', 'not in', []), 1620 ])
1670 ], 0, None, None, CONTEXT) 1621 self.assert_(date_ids == [date1_id])
1671 self.assert_(date_ids == [date1_id]) 1622
1672 1623 date_ids = self.date.search([
1673 date_ids = self.date.search(cursor, USER, [ 1624 ('date', '<', tomorrow),
1674 ('date', '<', tomorrow), 1625 ])
1675 ], 0, None, None, CONTEXT) 1626 self.assert_(date_ids == [date1_id])
1676 self.assert_(date_ids == [date1_id]) 1627
1677 1628 date_ids = self.date.search([
1678 date_ids = self.date.search(cursor, USER, [ 1629 ('date', '<', yesterday),
1679 ('date', '<', yesterday), 1630 ])
1680 ], 0, None, None, CONTEXT) 1631 self.assert_(date_ids == [])
1681 self.assert_(date_ids == []) 1632
1682 1633 date_ids = self.date.search([
1683 date_ids = self.date.search(cursor, USER, [ 1634 ('date', '<', today),
1684 ('date', '<', today), 1635 ])
1685 ], 0, None, None, CONTEXT) 1636 self.assert_(date_ids == [])
1686 self.assert_(date_ids == []) 1637
1687 1638 date_ids = self.date.search([
1688 date_ids = self.date.search(cursor, USER, [ 1639 ('date', '<=', today),
1689 ('date', '<=', today), 1640 ])
1690 ], 0, None, None, CONTEXT) 1641 self.assert_(date_ids == [date1_id])
1691 self.assert_(date_ids == [date1_id]) 1642
1692 1643 date_ids = self.date.search([
1693 date_ids = self.date.search(cursor, USER, [ 1644 ('date', '<=', yesterday),
1694 ('date', '<=', yesterday), 1645 ])
1695 ], 0, None, None, CONTEXT) 1646 self.assert_(date_ids == [])
1696 self.assert_(date_ids == []) 1647
1697 1648 date_ids = self.date.search([
1698 date_ids = self.date.search(cursor, USER, [ 1649 ('date', '<=', tomorrow),
1699 ('date', '<=', tomorrow), 1650 ])
1700 ], 0, None, None, CONTEXT) 1651 self.assert_(date_ids == [date1_id])
1701 self.assert_(date_ids == [date1_id]) 1652
1702 1653 date_ids = self.date.search([
1703 date_ids = self.date.search(cursor, USER, [ 1654 ('date', '>', tomorrow),
1704 ('date', '>', tomorrow), 1655 ])
1705 ], 0, None, None, CONTEXT) 1656 self.assert_(date_ids == [])
1706 self.assert_(date_ids == []) 1657
1707 1658 date_ids = self.date.search([
1708 date_ids = self.date.search(cursor, USER, [ 1659 ('date', '>', yesterday),
1709 ('date', '>', yesterday), 1660 ])
1710 ], 0, None, None, CONTEXT) 1661 self.assert_(date_ids == [date1_id])
1711 self.assert_(date_ids == [date1_id]) 1662
1712 1663 date_ids = self.date.search([
1713 date_ids = self.date.search(cursor, USER, [ 1664 ('date', '>', today),
1714 ('date', '>', today), 1665 ])
1715 ], 0, None, None, CONTEXT) 1666 self.assert_(date_ids == [])
1716 self.assert_(date_ids == []) 1667
1717 1668 date_ids = self.date.search([
1718 date_ids = self.date.search(cursor, USER, [ 1669 ('date', '>=', tomorrow),
1719 ('date', '>=', tomorrow), 1670 ])
1720 ], 0, None, None, CONTEXT) 1671 self.assert_(date_ids == [])
1721 self.assert_(date_ids == []) 1672
1722 1673 date_ids = self.date.search([
1723 date_ids = self.date.search(cursor, USER, [ 1674 ('date', '>=', yesterday),
1724 ('date', '>=', yesterday), 1675 ])
1725 ], 0, None, None, CONTEXT) 1676 self.assert_(date_ids == [date1_id])
1726 self.assert_(date_ids == [date1_id]) 1677
1727 1678 date_ids = self.date.search([
1728 date_ids = self.date.search(cursor, USER, [ 1679 ('date', '>=', today),
1729 ('date', '>=', today), 1680 ])
1730 ], 0, None, None, CONTEXT) 1681 self.assert_(date_ids == [date1_id])
1731 self.assert_(date_ids == [date1_id]) 1682
1732 1683 date2_id = self.date.create({
1733 date2_id = self.date.create(cursor, USER, { 1684 'date': yesterday,
1734 'date': yesterday, 1685 })
1735 }, CONTEXT) 1686 self.assert_(date2_id)
1736 self.assert_(date2_id) 1687
1737 1688 date2 = self.date.read(date2_id, ['date'])
1738 date2 = self.date.read(cursor, USER, date2_id, ['date'], CONTEXT) 1689 self.assert_(date2['date'] == yesterday)
1739 self.assert_(date2['date'] == yesterday) 1690
1740 1691 date_ids = self.date.search([
1741 date_ids = self.date.search(cursor, USER, [ 1692 ('date', '=', yesterday),
1742 ('date', '=', yesterday), 1693 ])
1743 ], 0, None, None, CONTEXT) 1694 self.assert_(date_ids == [date2_id])
1744 self.assert_(date_ids == [date2_id]) 1695
1745 1696 date_ids = self.date.search([
1746 date_ids = self.date.search(cursor, USER, [ 1697 ('date', 'in', [yesterday, today]),
1747 ('date', 'in', [yesterday, today]), 1698 ])
1748 ], 0, None, None, CONTEXT) 1699 self.assert_(date_ids == [date1_id, date2_id])
1749 self.assert_(date_ids == [date1_id, date2_id]) 1700
1750 1701 date_ids = self.date.search([
1751 date_ids = self.date.search(cursor, USER, [ 1702 ('date', 'not in', [yesterday, today]),
1752 ('date', 'not in', [yesterday, today]), 1703 ])
1753 ], 0, None, None, CONTEXT) 1704 self.assert_(date_ids == [])
1754 self.assert_(date_ids == []) 1705
1755 1706 date3_id = self.date.create({})
1756 date3_id = self.date.create(cursor, USER, {}, CONTEXT) 1707 self.assert_(date3_id)
1757 self.assert_(date3_id) 1708
1758 1709 date3 = self.date.read(date3_id, ['date'])
1759 date3 = self.date.read(cursor, USER, date3_id, ['date'], CONTEXT) 1710 self.assert_(date3['date'] == None)
1760 self.assert_(date3['date'] == None) 1711
1761 1712 date4_id = self.date_default.create({})
1762 date4_id = self.date_default.create(cursor, USER, {}, CONTEXT) 1713 self.assert_(date4_id)
1763 self.assert_(date4_id) 1714
1764 1715 date4 = self.date_default.read(date4_id, ['date'])
1765 date4 = self.date_default.read(cursor, USER, date4_id, ['date'], 1716 self.assert_(date4['date'] == default_date)
1766 CONTEXT) 1717
1767 self.assert_(date4['date'] == default_date) 1718 self.date.write(date1_id, {
1768 1719 'date': yesterday,
1769 self.date.write(cursor, USER, date1_id, { 1720 })
1770 'date': yesterday, 1721 date1 = self.date.read(date1_id, ['date'])
1771 }, CONTEXT) 1722 self.assert_(date1['date'] == yesterday)
1772 date1 = self.date.read(cursor, USER, date1_id, ['date'], CONTEXT) 1723
1773 self.assert_(date1['date'] == yesterday) 1724 self.date.write(date2_id, {
1774 1725 'date': today,
1775 self.date.write(cursor, USER, date2_id, { 1726 })
1776 'date': today, 1727 date2 = self.date.read(date2_id, ['date'])
1777 }, CONTEXT) 1728 self.assert_(date2['date'] == today)
1778 date2 = self.date.read(cursor, USER, date2_id, ['date'], CONTEXT) 1729
1779 self.assert_(date2['date'] == today) 1730 self.failUnlessRaises(Exception, self.date.create, {
1780 1731 'date': 'test',
1781 self.failUnlessRaises(Exception, self.date.create, cursor, USER, { 1732 })
1782 'date': 'test', 1733
1783 }, CONTEXT) 1734 self.failUnlessRaises(Exception, self.date.write, date1_id, {
1784 1735 'date': 'test',
1785 self.failUnlessRaises(Exception, self.date.write, cursor, USER, 1736 })
1786 date1_id, { 1737
1787 'date': 'test', 1738 self.failUnlessRaises(Exception, self.date.create, {
1788 }, CONTEXT) 1739 'date': 1,
1789 1740 })
1790 self.failUnlessRaises(Exception, self.date.create, cursor, USER, { 1741
1791 'date': 1, 1742 self.failUnlessRaises(Exception, self.date.write, date1_id, {
1792 }, CONTEXT) 1743 'date': 1,
1793 1744 })
1794 self.failUnlessRaises(Exception, self.date.write, cursor, USER, 1745
1795 date1_id, { 1746 self.failUnlessRaises(Exception, self.date.create, {
1796 'date': 1,
1797 }, CONTEXT)
1798
1799 self.failUnlessRaises(Exception, self.date.create, cursor, USER, {
1800 'date': datetime.datetime.now(), 1747 'date': datetime.datetime.now(),
1801 }, CONTEXT) 1748 })
1802 1749
1803 self.failUnlessRaises(Exception, self.date.write, cursor, USER, 1750 self.failUnlessRaises(Exception, self.date.write, date1_id, {
1804 date1_id, { 1751 'date': datetime.datetime.now(),
1805 'date': datetime.datetime.now(), 1752 })
1806 }, CONTEXT) 1753
1807 1754 self.failUnlessRaises(Exception, self.date.create, {
1808 self.failUnlessRaises(Exception, self.date.create, cursor, USER, {
1809 'date': '2009-13-01', 1755 'date': '2009-13-01',
1810 }, CONTEXT) 1756 })
1811 1757
1812 self.failUnlessRaises(Exception, self.date.write, cursor, USER, 1758 self.failUnlessRaises(Exception, self.date.write, date1_id, {
1813 date1_id, { 1759 'date': '2009-02-29',
1814 'date': '2009-02-29', 1760 })
1815 }, CONTEXT) 1761
1816 1762 date5_id = self.date.create({
1817 date5_id = self.date.create(cursor, USER, { 1763 'date': '2009-01-01',
1818 'date': '2009-01-01', 1764 })
1819 }, CONTEXT) 1765 self.assert_(date5_id)
1820 self.assert_(date5_id) 1766 date5 = self.date.read(date5_id, ['date'])
1821 date5 = self.date.read(cursor, USER, date5_id, ['date'], CONTEXT) 1767 self.assert_(date5['date'] == datetime.date(2009, 1, 1))
1822 self.assert_(date5['date'] == datetime.date(2009, 1, 1)) 1768
1823 1769 self.failUnlessRaises(Exception, self.date_required.create, {})
1824 self.failUnlessRaises(Exception, self.date_required.create, cursor, 1770 transaction.cursor.rollback()
1825 USER, {}, CONTEXT) 1771
1826 cursor.rollback() 1772 date6_id = self.date_required.create({
1827 1773 'date': today,
1828 date6_id = self.date_required.create(cursor, USER, { 1774 })
1829 'date': today, 1775 self.assert_(date6_id)
1830 }, CONTEXT) 1776
1831 self.assert_(date6_id) 1777 date7_id = self.date.create({
1832 1778 'date': None,
1833 date7_id = self.date.create(cursor, USER, { 1779 })
1834 'date': None, 1780 self.assert_(date7_id)
1835 }, CONTEXT) 1781
1836 self.assert_(date7_id) 1782 date8_id = self.date.create({
1837 1783 'date': False,
1838 date8_id = self.date.create(cursor, USER, { 1784 })
1839 'date': False, 1785 self.assert_(date8_id)
1840 }, CONTEXT) 1786
1841 self.assert_(date8_id) 1787 transaction.cursor.rollback()
1842
1843 cursor.rollback()
1844 cursor.close()
1845 1788
1846 def test0090datetime(self): 1789 def test0090datetime(self):
1847 ''' 1790 '''
1848 Test DateTime. 1791 Test DateTime.
1849 ''' 1792 '''
1850 cursor = DB.cursor() 1793 with Transaction().start(DB_NAME, USER, CONTEXT) as transaction:
1851 1794 today = datetime.datetime(2009, 1, 1, 12, 0, 0)
1852 today = datetime.datetime(2009, 1, 1, 12, 0, 0) 1795 tomorrow = today + datetime.timedelta(1)
1853 tomorrow = today + datetime.timedelta(1) 1796 yesterday = today - datetime.timedelta(1)
1854 yesterday = today - datetime.timedelta(1) 1797 default_datetime = datetime.datetime(2000, 1, 1, 12, 0, 0)
1855 default_datetime = datetime.datetime(2000, 1, 1, 12, 0, 0) 1798
1856 1799 datetime1_id = self.datetime.create({
1857 datetime1_id = self.datetime.create(cursor, USER, { 1800 'datetime': today,
1858 'datetime': today, 1801 })
1859 }, CONTEXT) 1802 self.assert_(datetime1_id)
1860 self.assert_(datetime1_id) 1803
1861 1804 datetime1 = self.datetime.read(datetime1_id, ['datetime'])
1862 datetime1 = self.datetime.read(cursor, USER, datetime1_id, 1805 self.assert_(datetime1['datetime'] == today)
1863 ['datetime'], CONTEXT) 1806
1864 self.assert_(datetime1['datetime'] == today) 1807 datetime_ids = self.datetime.search([
1865 1808 ('datetime', '=', today),
1866 datetime_ids = self.datetime.search(cursor, USER, [ 1809 ])
1867 ('datetime', '=', today), 1810 self.assert_(datetime_ids == [datetime1_id])
1868 ], 0, None, None, CONTEXT) 1811
1869 self.assert_(datetime_ids == [datetime1_id]) 1812 datetime_ids = self.datetime.search([
1870 1813 ('datetime', '=', tomorrow),
1871 datetime_ids = self.datetime.search(cursor, USER, [ 1814 ])
1872 ('datetime', '=', tomorrow), 1815 self.assert_(datetime_ids == [])
1873 ], 0, None, None, CONTEXT) 1816
1874 self.assert_(datetime_ids == []) 1817 datetime_ids = self.datetime.search([
1875 1818 ('datetime', '=', False),
1876 datetime_ids = self.datetime.search(cursor, USER, [ 1819 ])
1877 ('datetime', '=', False), 1820 self.assert_(datetime_ids == [])
1878 ], 0, None, None, CONTEXT) 1821
1879 self.assert_(datetime_ids == []) 1822 datetime_ids = self.datetime.search([
1880 1823 ('datetime', '!=', today),
1881 datetime_ids = self.datetime.search(cursor, USER, [ 1824 ])
1882 ('datetime', '!=', today), 1825 self.assert_(datetime_ids == [])
1883 ], 0, None, None, CONTEXT) 1826
1884 self.assert_(datetime_ids == []) 1827 datetime_ids = self.datetime.search([
1885 1828 ('datetime', '!=', tomorrow),
1886 datetime_ids = self.datetime.search(cursor, USER, [ 1829 ])
1887 ('datetime', '!=', tomorrow), 1830 self.assert_(datetime_ids == [datetime1_id])
1888 ], 0, None, None, CONTEXT) 1831
1889 self.assert_(datetime_ids == [datetime1_id]) 1832 datetime_ids = self.datetime.search([
1890 1833 ('datetime', '!=', False),
1891 datetime_ids = self.datetime.search(cursor, USER, [ 1834 ])
1892 ('datetime', '!=', False), 1835 self.assert_(datetime_ids == [datetime1_id])
1893 ], 0, None, None, CONTEXT) 1836
1894 self.assert_(datetime_ids == [datetime1_id]) 1837 datetime_ids = self.datetime.search([
1895 1838 ('datetime', 'in', [today]),
1896 datetime_ids = self.datetime.search(cursor, USER, [ 1839 ])
1897 ('datetime', 'in', [today]), 1840 self.assert_(datetime_ids == [datetime1_id])
1898 ], 0, None, None, CONTEXT) 1841
1899 self.assert_(datetime_ids == [datetime1_id]) 1842 datetime_ids = self.datetime.search([
1900 1843 ('datetime', 'in', [tomorrow]),
1901 datetime_ids = self.datetime.search(cursor, USER, [ 1844 ])
1902 ('datetime', 'in', [tomorrow]), 1845 self.assert_(datetime_ids == [])
1903 ], 0, None, None, CONTEXT) 1846
1904 self.assert_(datetime_ids == []) 1847 datetime_ids = self.datetime.search([
1905 1848 ('datetime', 'in', [False]),
1906 datetime_ids = self.datetime.search(cursor, USER, [ 1849 ])
1907 ('datetime', 'in', [False]), 1850 self.assert_(datetime_ids == [])
1908 ], 0, None, None, CONTEXT) 1851
1909 self.assert_(datetime_ids == []) 1852 datetime_ids = self.datetime.search([
1910 1853 ('datetime', 'in', []),
1911 datetime_ids = self.datetime.search(cursor, USER, [ 1854 ])
1912 ('datetime', 'in', []), 1855 self.assert_(datetime_ids == [])
1913 ], 0, None, None, CONTEXT) 1856
1914 self.assert_(datetime_ids == []) 1857 datetime_ids = self.datetime.search([
1915 1858 ('datetime', 'not in', [today]),
1916 datetime_ids = self.datetime.search(cursor, USER, [ 1859 ])
1917 ('datetime', 'not in', [today]), 1860 self.assert_(datetime_ids == [])
1918 ], 0, None, None, CONTEXT) 1861
1919 self.assert_(datetime_ids == []) 1862 datetime_ids = self.datetime.search([
1920 1863 ('datetime', 'not in', [tomorrow]),
1921 datetime_ids = self.datetime.search(cursor, USER, [ 1864 ])
1922 ('datetime', 'not in', [tomorrow]), 1865 self.assert_(datetime_ids == [datetime1_id])
1923 ], 0, None, None, CONTEXT) 1866
1924 self.assert_(datetime_ids == [datetime1_id]) 1867 datetime_ids = self.datetime.search([
1925 1868 ('datetime', 'not in', [False]),
1926 datetime_ids = self.datetime.search(cursor, USER, [ 1869 ])
1927 ('datetime', 'not in', [False]), 1870 self.assert_(datetime_ids == [datetime1_id])
1928 ], 0, None, None, CONTEXT) 1871
1929 self.assert_(datetime_ids == [datetime1_id]) 1872 datetime_ids = self.datetime.search([
1930 1873 ('datetime', 'not in', []),
1931 datetime_ids = self.datetime.search(cursor, USER, [ 1874 ])
1932 ('datetime', 'not in', []), 1875 self.assert_(datetime_ids == [datetime1_id])
1933 ], 0, None, None, CONTEXT) 1876
1934 self.assert_(datetime_ids == [datetime1_id]) 1877 datetime_ids = self.datetime.search([
1935 1878 ('datetime', '<', tomorrow),
1936 datetime_ids = self.datetime.search(cursor, USER, [ 1879 ])
1937 ('datetime', '<', tomorrow), 1880 self.assert_(datetime_ids == [datetime1_id])
1938 ], 0, None, None, CONTEXT) 1881
1939 self.assert_(datetime_ids == [datetime1_id]) 1882 datetime_ids = self.datetime.search([
1940 1883 ('datetime', '<', yesterday),
1941 datetime_ids = self.datetime.search(cursor, USER, [ 1884 ])
1942 ('datetime', '<', yesterday), 1885 self.assert_(datetime_ids == [])
1943 ], 0, None, None, CONTEXT) 1886
1944 self.assert_(datetime_ids == []) 1887 datetime_ids = self.datetime.search([
1945 1888 ('datetime', '<', today),
1946 datetime_ids = self.datetime.search(cursor, USER, [ 1889 ])
1947 ('datetime', '<', today), 1890 self.assert_(datetime_ids == [])
1948 ], 0, None, None, CONTEXT) 1891
1949 self.assert_(datetime_ids == []) 1892 datetime_ids = self.datetime.search([
1950 1893 ('datetime', '<=', today),
1951 datetime_ids = self.datetime.search(cursor, USER, [ 1894 ])
1952 ('datetime', '<=', today), 1895 self.assert_(datetime_ids == [datetime1_id])
1953 ], 0, None, None, CONTEXT) 1896
1954 self.assert_(datetime_ids == [datetime1_id]) 1897 datetime_ids = self.datetime.search([
1955 1898 ('datetime', '<=', yesterday),
1956 datetime_ids = self.datetime.search(cursor, USER, [ 1899 ])
1957 ('datetime', '<=', yesterday), 1900 self.assert_(datetime_ids == [])
1958 ], 0, None, None, CONTEXT) 1901
1959 self.assert_(datetime_ids == []) 1902 datetime_ids = self.datetime.search([
1960 1903 ('datetime', '<=', tomorrow),
1961 datetime_ids = self.datetime.search(cursor, USER, [ 1904 ])
1962 ('datetime', '<=', tomorrow), 1905 self.assert_(datetime_ids == [datetime1_id])
1963 ], 0, None, None, CONTEXT) 1906
1964 self.assert_(datetime_ids == [datetime1_id]) 1907 datetime_ids = self.datetime.search([
1965 1908 ('datetime', '>', tomorrow),
1966 datetime_ids = self.datetime.search(cursor, USER, [ 1909 ])
1967 ('datetime', '>', tomorrow), 1910 self.assert_(datetime_ids == [])
1968 ], 0, None, None, CONTEXT) 1911
1969 self.assert_(datetime_ids == []) 1912 datetime_ids = self.datetime.search([
1970 1913 ('datetime', '>', yesterday),
1971 datetime_ids = self.datetime.search(cursor, USER, [ 1914 ])
1972 ('datetime', '>', yesterday), 1915 self.assert_(datetime_ids == [datetime1_id])
1973 ], 0, None, None, CONTEXT) 1916
1974 self.assert_(datetime_ids == [datetime1_id]) 1917 datetime_ids = self.datetime.search([
1975 1918 ('datetime', '>', today),
1976 datetime_ids = self.datetime.search(cursor, USER, [ 1919 ])
1977 ('datetime', '>', today), 1920 self.assert_(datetime_ids == [])
1978 ], 0, None, None, CONTEXT) 1921
1979 self.assert_(datetime_ids == []) 1922 datetime_ids = self.datetime.search([
1980 1923 ('datetime', '>=', tomorrow),
1981 datetime_ids = self.datetime.search(cursor, USER, [ 1924 ])
1982 ('datetime', '>=', tomorrow), 1925 self.assert_(datetime_ids == [])
1983 ], 0, None, None, CONTEXT) 1926
1984 self.assert_(datetime_ids == []) 1927 datetime_ids = self.datetime.search([
1985 1928 ('datetime', '>=', yesterday),
1986 datetime_ids = self.datetime.search(cursor, USER, [ 1929 ])
1987 ('datetime', '>=', yesterday), 1930 self.assert_(datetime_ids == [datetime1_id])
1988 ], 0, None, None, CONTEXT) 1931
1989 self.assert_(datetime_ids == [datetime1_id]) 1932 datetime_ids = self.datetime.search([
1990 1933 ('datetime', '>=', today),
1991 datetime_ids = self.datetime.search(cursor, USER, [ 1934 ])
1992 ('datetime', '>=', today), 1935 self.assert_(datetime_ids == [datetime1_id])
1993 ], 0, None, None, CONTEXT) 1936
1994 self.assert_(datetime_ids == [datetime1_id]) 1937 datetime2_id = self.datetime.create({
1995 1938 'datetime': yesterday,
1996 datetime2_id = self.datetime.create(cursor, USER, { 1939 })
1997 'datetime': yesterday, 1940 self.assert_(datetime2_id)
1998 }, CONTEXT) 1941
1999 self.assert_(datetime2_id) 1942 datetime2 = self.datetime.read(datetime2_id, ['datetime'])
2000 1943 self.assert_(datetime2['datetime'] == yesterday)
2001 datetime2 = self.datetime.read(cursor, USER, datetime2_id, 1944
2002 ['datetime'], CONTEXT) 1945 datetime_ids = self.datetime.search([
2003 self.assert_(datetime2['datetime'] == yesterday) 1946 ('datetime', '=', yesterday),
2004 1947 ])
2005 datetime_ids = self.datetime.search(cursor, USER, [ 1948 self.assert_(datetime_ids == [datetime2_id])
2006 ('datetime', '=', yesterday), 1949
2007 ], 0, None, None, CONTEXT) 1950 datetime_ids = self.datetime.search([
2008 self.assert_(datetime_ids == [datetime2_id]) 1951 ('datetime', 'in', [yesterday, today]),
2009 1952 ])
2010 datetime_ids = self.datetime.search(cursor, USER, [ 1953 self.assert_(datetime_ids == [datetime1_id, datetime2_id])
2011 ('datetime', 'in', [yesterday, today]), 1954
2012 ], 0, None, None, CONTEXT) 1955 datetime_ids = self.datetime.search([
2013 self.assert_(datetime_ids == [datetime1_id, datetime2_id]) 1956 ('datetime', 'not in', [yesterday, today]),
2014 1957 ])
2015 datetime_ids = self.datetime.search(cursor, USER, [ 1958 self.assert_(datetime_ids == [])
2016 ('datetime', 'not in', [yesterday, today]), 1959
2017 ], 0, None, None, CONTEXT) 1960 datetime3_id = self.datetime.create({})
2018 self.assert_(datetime_ids == []) 1961 self.assert_(datetime3_id)
2019 1962
2020 datetime3_id = self.datetime.create(cursor, USER, {}, CONTEXT) 1963 datetime3 = self.datetime.read(datetime3_id, ['datetime'])
2021 self.assert_(datetime3_id) 1964 self.assert_(datetime3['datetime'] == None)
2022 1965
2023 datetime3 = self.datetime.read(cursor, USER, datetime3_id, 1966 datetime4_id = self.datetime_default.create({})
2024 ['datetime'], CONTEXT) 1967 self.assert_(datetime4_id)
2025 self.assert_(datetime3['datetime'] == None) 1968
2026 1969 datetime4 = self.datetime_default.read(datetime4_id, ['datetime'])
2027 datetime4_id = self.datetime_default.create(cursor, USER, {}, CONTEXT) 1970 self.assert_(datetime4['datetime'] == default_datetime)
2028 self.assert_(datetime4_id) 1971
2029 1972 self.datetime.write(datetime1_id, {
2030 datetime4 = self.datetime_default.read(cursor, USER, datetime4_id, 1973 'datetime': yesterday,
2031 ['datetime'], CONTEXT) 1974 })
2032 self.assert_(datetime4['datetime'] == default_datetime) 1975 datetime1 = self.datetime.read(datetime1_id, ['datetime'])
2033 1976 self.assert_(datetime1['datetime'] == yesterday)
2034 self.datetime.write(cursor, USER, datetime1_id, { 1977
2035 'datetime': yesterday, 1978 self.datetime.write(datetime2_id, {
2036 }, CONTEXT) 1979 'datetime': today,
2037 datetime1 = self.datetime.read(cursor, USER, datetime1_id, 1980 })
2038 ['datetime'], CONTEXT) 1981 datetime2 = self.datetime.read(datetime2_id, ['datetime'])
2039 self.assert_(datetime1['datetime'] == yesterday) 1982 self.assert_(datetime2['datetime'] == today)
2040 1983
2041 self.datetime.write(cursor, USER, datetime2_id, { 1984 self.failUnlessRaises(Exception, self.datetime.create, {
2042 'datetime': today, 1985 'datetime': 'test',
2043 }, CONTEXT) 1986 })
2044 datetime2 = self.datetime.read(cursor, USER, datetime2_id, 1987
2045 ['datetime'], CONTEXT) 1988 self.failUnlessRaises(Exception, self.datetime.write, datetime1_id,
2046 self.assert_(datetime2['datetime'] == today) 1989 {
2047 1990 'datetime': 'test',
2048 self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { 1991 })
2049 'datetime': 'test', 1992
2050 }, CONTEXT) 1993 self.failUnlessRaises(Exception, self.datetime.create, {
2051 1994 'datetime': 1,
2052 self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, 1995 })
2053 datetime1_id, { 1996
2054 'datetime': 'test', 1997 self.failUnlessRaises(Exception, self.datetime.write, datetime1_id,
2055 }, CONTEXT) 1998 {
2056 1999 'datetime': 1,
2057 self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { 2000 })
2058 'datetime': 1, 2001
2059 }, CONTEXT) 2002 self.failUnlessRaises(Exception, self.datetime.create, {
2060 2003 'datetime': datetime.date.today(),
2061 self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, 2004 })
2062 datetime1_id, { 2005
2063 'datetime': 1, 2006 self.failUnlessRaises(Exception, self.datetime.write, datetime1_id,
2064 }, CONTEXT) 2007 {
2065 2008 'datetime': datetime.date.today(),
2066 self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { 2009 })
2067 'datetime': datetime.date.today(), 2010
2068 }, CONTEXT) 2011 self.failUnlessRaises(Exception, self.datetime.create, {
2069 2012 'datetime': '2009-13-01 12:30:00',
2070 self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, 2013 })
2071 datetime1_id, { 2014
2072 'datetime': datetime.date.today(), 2015 self.failUnlessRaises(Exception, self.datetime.write, datetime1_id,
2073 }, CONTEXT) 2016 {
2074 2017 'datetime': '2009-02-29 12:30:00',
2075 self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { 2018 })
2076 'datetime': '2009-13-01 12:30:00', 2019
2077 }, CONTEXT) 2020 self.failUnlessRaises(Exception, self.datetime.write, datetime1_id,
2078 2021 {
2079 self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, 2022 'datetime': '2009-01-01 25:00:00',
2080 datetime1_id, { 2023 })
2081 'datetime': '2009-02-29 12:30:00', 2024
2082 }, CONTEXT) 2025 datetime5_id = self.datetime.create({
2083 2026 'datetime': '2009-01-01 12:00:00',
2084 self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, 2027 })
2085 datetime1_id, { 2028 self.assert_(datetime5_id)
2086 'datetime': '2009-01-01 25:00:00', 2029 datetime5 = self.datetime.read(datetime5_id, ['datetime'])
2087 }, CONTEXT) 2030 self.assert_(datetime5['datetime'] == datetime.datetime(2009, 1, 1, 12,
2088 2031 0, 0))
2089 datetime5_id = self.datetime.create(cursor, USER, { 2032
2090 'datetime': '2009-01-01 12:00:00', 2033 self.failUnlessRaises(Exception, self.datetime_required.create, {})
2091 }, CONTEXT) 2034 transaction.cursor.rollback()
2092 self.assert_(datetime5_id) 2035
2093 datetime5 = self.datetime.read(cursor, USER, datetime5_id, 2036 datetime6_id = self.datetime_required.create({
2094 ['datetime'], CONTEXT) 2037 'datetime': today,
2095 self.assert_(datetime5['datetime'] == datetime.datetime(2009, 1, 1, 12, 2038 })
2096 0, 0)) 2039 self.assert_(datetime6_id)
2097 2040
2098 self.failUnlessRaises(Exception, self.datetime_required.create, cursor, 2041 datetime7_id = self.datetime.create({
2099 USER, {}, CONTEXT) 2042 'datetime': None,
2100 cursor.rollback() 2043 })
2101 2044 self.assert_(datetime7_id)
2102 datetime6_id = self.datetime_required.create(cursor, USER, { 2045
2103 'datetime': today, 2046 datetime8_id = self.datetime.create({
2104 }, CONTEXT) 2047 'datetime': False,
2105 self.assert_(datetime6_id) 2048 })
2106 2049 self.assert_(datetime8_id)
2107 datetime7_id = self.datetime.create(cursor, USER, { 2050
2108 'datetime': None, 2051 datetime9_id = self.datetime.create({
2109 }, CONTEXT) 2052 'datetime': today.replace(microsecond=1),
2110 self.assert_(datetime7_id) 2053 })
2111 2054 self.assert_(datetime9_id)
2112 datetime8_id = self.datetime.create(cursor, USER, { 2055 datetime9 = self.datetime.read(datetime9_id, ['datetime'])
2113 'datetime': False, 2056 self.assert_(datetime9['datetime'] == today)
2114 }, CONTEXT) 2057
2115 self.assert_(datetime8_id) 2058 transaction.cursor.rollback()
2116
2117 datetime9_id = self.datetime.create(cursor, USER, {
2118 'datetime': today.replace(microsecond=1),
2119 }, CONTEXT)
2120 self.assert_(datetime9_id)
2121 datetime9 = self.datetime.read(cursor, USER, datetime9_id,
2122 ['datetime'], CONTEXT)
2123 self.assert_(datetime9['datetime'] == today)
2124
2125 cursor.rollback()
2126 cursor.close()
2127 2059
2128 def suite(): 2060 def suite():
2129 return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase) 2061 return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase)
2130 2062
2131 if __name__ == '__main__': 2063 if __name__ == '__main__':
2132 suite = suite() 2064 suite = suite()
2133 unittest.TextTestRunner(verbosity=2).run(suite) 2065 unittest.TextTestRunner(verbosity=2).run(suite)
OLDNEW
« no previous file with comments | « trytond/tests/test_exportdata.py ('k') | trytond/tests/test_importdata.py » ('j') | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b