3140 lines
102 KiB
Python
3140 lines
102 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
#This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
#this repository contains the full copyright notices and license terms.
|
|
import sys
|
|
try:
|
|
import cdecimal
|
|
if 'decimal' not in sys.modules:
|
|
sys.modules['decimal'] = cdecimal
|
|
except ImportError:
|
|
import decimal
|
|
sys.modules['cdecimal'] = decimal
|
|
import unittest
|
|
import datetime
|
|
from decimal import Decimal
|
|
from trytond.tests.test_tryton import POOL, DB_NAME, USER, CONTEXT, \
|
|
install_module
|
|
from trytond.transaction import Transaction
|
|
|
|
|
|
class FieldsTestCase(unittest.TestCase):
|
|
'''
|
|
Test Fields.
|
|
'''
|
|
|
|
def setUp(self):
|
|
install_module('test')
|
|
self.boolean = POOL.get('test.boolean')
|
|
self.boolean_default = POOL.get('test.boolean_default')
|
|
|
|
self.integer = POOL.get('test.integer')
|
|
self.integer_default = POOL.get('test.integer_default')
|
|
self.integer_required = POOL.get('test.integer_required')
|
|
|
|
self.float = POOL.get('test.float')
|
|
self.float_default = POOL.get('test.float_default')
|
|
self.float_required = POOL.get('test.float_required')
|
|
self.float_digits = POOL.get('test.float_digits')
|
|
|
|
self.numeric = POOL.get('test.numeric')
|
|
self.numeric_default = POOL.get('test.numeric_default')
|
|
self.numeric_required = POOL.get('test.numeric_required')
|
|
self.numeric_digits = POOL.get('test.numeric_digits')
|
|
|
|
self.char = POOL.get('test.char')
|
|
self.char_default = POOL.get('test.char_default')
|
|
self.char_required = POOL.get('test.char_required')
|
|
self.char_size = POOL.get('test.char_size')
|
|
self.char_translate = POOL.get('test.char_translate')
|
|
|
|
self.text = POOL.get('test.text')
|
|
self.text_default = POOL.get('test.text_default')
|
|
self.text_required = POOL.get('test.text_required')
|
|
self.text_size = POOL.get('test.text_size')
|
|
self.text_translate = POOL.get('test.text_translate')
|
|
|
|
self.sha = POOL.get('test.sha')
|
|
self.sha_default = POOL.get('test.sha_default')
|
|
self.sha_required = POOL.get('test.sha_required')
|
|
|
|
self.date = POOL.get('test.date')
|
|
self.date_default = POOL.get('test.date_default')
|
|
self.date_required = POOL.get('test.date_required')
|
|
|
|
self.datetime = POOL.get('test.datetime')
|
|
self.datetime_default = POOL.get('test.datetime_default')
|
|
self.datetime_required = POOL.get('test.datetime_required')
|
|
self.datetime_format = POOL.get('test.datetime_format')
|
|
|
|
self.time = POOL.get('test.time')
|
|
self.time_default = POOL.get('test.time_default')
|
|
self.time_required = POOL.get('test.time_required')
|
|
self.time_format = POOL.get('test.time_format')
|
|
|
|
self.one2one = POOL.get('test.one2one')
|
|
self.one2one_target = POOL.get('test.one2one.target')
|
|
self.one2one_required = POOL.get('test.one2one_required')
|
|
|
|
self.one2many = POOL.get('test.one2many')
|
|
self.one2many_target = POOL.get('test.one2many.target')
|
|
self.one2many_required = POOL.get('test.one2many_required')
|
|
self.one2many_reference = POOL.get('test.one2many_reference')
|
|
self.one2many_reference_target = POOL.get(
|
|
'test.one2many_reference.target')
|
|
self.one2many_size = POOL.get('test.one2many_size')
|
|
self.one2many_size_pyson = POOL.get('test.one2many_size_pyson')
|
|
|
|
self.many2many = POOL.get('test.many2many')
|
|
self.many2many_target = POOL.get('test.many2many.target')
|
|
self.many2many_required = POOL.get('test.many2many_required')
|
|
self.many2many_reference = POOL.get('test.many2many_reference')
|
|
self.many2many_reference_target = POOL.get(
|
|
'test.many2many_reference.target')
|
|
self.many2many_size = POOL.get('test.many2many_size')
|
|
self.many2many_size_target = POOL.get('test.many2many_size.target')
|
|
|
|
self.reference = POOL.get('test.reference')
|
|
self.reference_target = POOL.get('test.reference.target')
|
|
self.reference_required = POOL.get('test.reference_required')
|
|
|
|
self.property_ = POOL.get('test.property')
|
|
self.ir_property = POOL.get('ir.property')
|
|
self.model_field = POOL.get('ir.model.field')
|
|
|
|
def test0010boolean(self):
|
|
'''
|
|
Test Boolean.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
boolean1 = self.boolean.create({
|
|
'boolean': True,
|
|
})
|
|
self.assert_(boolean1)
|
|
self.assertEqual(boolean1.boolean, True)
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', '=', True),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', '!=', True),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'in', [True]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'in', [False]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'not in', [True]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'not in', [False]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
boolean2 = self.boolean.create({
|
|
'boolean': False,
|
|
})
|
|
self.assert_(boolean2)
|
|
self.assertEqual(boolean2.boolean, False)
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', '=', False),
|
|
])
|
|
self.assertEqual(booleans, [boolean2])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'in', [True, False]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1, boolean2])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', 'not in', [True, False]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
boolean3 = self.boolean.create({})
|
|
self.assert_(boolean3)
|
|
self.assertEqual(boolean3.boolean, False)
|
|
|
|
# Test search with NULL value
|
|
boolean4 = self.boolean.create({
|
|
'boolean': None,
|
|
})
|
|
self.assert_(boolean4)
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', '=', False),
|
|
])
|
|
self.assertEqual(booleans,
|
|
[boolean2, boolean3, boolean4])
|
|
|
|
booleans = self.boolean.search([
|
|
('boolean', '!=', False),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
boolean4 = self.boolean_default.create({})
|
|
self.assert_(boolean4)
|
|
self.assert_(boolean4.boolean == True)
|
|
|
|
self.boolean.write([boolean1], {
|
|
'boolean': False,
|
|
})
|
|
self.assertEqual(boolean1.boolean, False)
|
|
|
|
self.boolean.write([boolean2], {
|
|
'boolean': True,
|
|
})
|
|
self.assertEqual(boolean2.boolean, True)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0020integer(self):
|
|
'''
|
|
Test Integer.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
integer1 = self.integer.create({
|
|
'integer': 1,
|
|
})
|
|
self.assert_(integer1)
|
|
self.assertEqual(integer1.integer, 1)
|
|
|
|
integers = self.integer.search([
|
|
('integer', '=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '=', 0),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '!=', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '!=', 0),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'in', [1]),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'in', [0]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'in', []),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'not in', [1]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'not in', [0]),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'not in', []),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<', 5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<', -5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<=', 5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<=', -5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '<=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>', 5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>', -5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>=', 5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>=', -5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = self.integer.search([
|
|
('integer', '>=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integer2 = self.integer.create({
|
|
'integer': 0,
|
|
})
|
|
self.assert_(integer2)
|
|
self.assertEqual(integer2.integer, 0)
|
|
|
|
integers = self.integer.search([
|
|
('integer', '=', 0),
|
|
])
|
|
self.assertEqual(integers, [integer2])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'in', [0, 1]),
|
|
])
|
|
self.assertEqual(integers, [integer1, integer2])
|
|
|
|
integers = self.integer.search([
|
|
('integer', 'not in', [0, 1]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integer3 = self.integer.create({})
|
|
self.assert_(integer3)
|
|
self.assertEqual(integer3.integer, None)
|
|
|
|
integer4 = self.integer_default.create({})
|
|
self.assert_(integer4)
|
|
self.assertEqual(integer4.integer, 5)
|
|
|
|
self.integer.write([integer1], {
|
|
'integer': 0,
|
|
})
|
|
self.assertEqual(integer1.integer, 0)
|
|
|
|
self.integer.write([integer2], {
|
|
'integer': 1,
|
|
})
|
|
self.assertEqual(integer2.integer, 1)
|
|
|
|
self.assertRaises(Exception, self.integer.create, {
|
|
'integer': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.integer.write, [integer1], {
|
|
'integer': 'test',
|
|
})
|
|
|
|
# We should catch UserError but mysql does not raise an
|
|
# IntegrityError but an OperationalError
|
|
self.assertRaises(Exception, self.integer_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
integer5 = self.integer_required.create({
|
|
'integer': 0,
|
|
})
|
|
self.assert_(integer5)
|
|
self.assertEqual(integer5.integer, 0)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0030float(self):
|
|
'''
|
|
Test Float.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
float1 = self.float.create({
|
|
'float': 1.1,
|
|
})
|
|
self.assert_(float1)
|
|
self.assertEqual(float1.float, 1.1)
|
|
|
|
floats = self.float.search([
|
|
('float', '=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '=', 0),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '!=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '!=', 0),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', 'in', [1.1]),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', 'in', [0]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', 'in', []),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', 'not in', [1.1]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', 'not in', [0]),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', 'not in', []),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '<', 5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '<', -5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '<', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '<=', 5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '<=', -5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '<=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '>', 5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '>', -5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '>', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '>=', 5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = self.float.search([
|
|
('float', '>=', -5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = self.float.search([
|
|
('float', '>=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
float2 = self.float.create({
|
|
'float': 0,
|
|
})
|
|
self.assert_(float2)
|
|
self.assertEqual(float2.float, 0)
|
|
|
|
floats = self.float.search([
|
|
('float', '=', 0),
|
|
])
|
|
self.assertEqual(floats, [float2])
|
|
|
|
floats = self.float.search([
|
|
('float', 'in', [0, 1.1]),
|
|
])
|
|
self.assertEqual(floats, [float1, float2])
|
|
|
|
floats = self.float.search([
|
|
('float', 'not in', [0, 1.1]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
float3 = self.float.create({})
|
|
self.assert_(float3)
|
|
self.assertEqual(float3.float, None)
|
|
|
|
float4 = self.float_default.create({})
|
|
self.assert_(float4)
|
|
self.assertEqual(float4.float, 5.5)
|
|
|
|
self.float.write([float1], {
|
|
'float': 0,
|
|
})
|
|
self.assertEqual(float1.float, 0)
|
|
|
|
self.float.write([float2], {
|
|
'float': 1.1,
|
|
})
|
|
self.assertEqual(float2.float, 1.1)
|
|
|
|
self.assertRaises(Exception, self.float.create, {
|
|
'float': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.float.write, [float1], {
|
|
'float': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.float_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
float5 = self.float_required.create({
|
|
'float': 0.0,
|
|
})
|
|
self.assertEqual(float5.float, 0.0)
|
|
|
|
float6 = self.float_digits.create({
|
|
'digits': 1,
|
|
'float': 1.1,
|
|
})
|
|
self.assert_(float6)
|
|
|
|
self.assertRaises(Exception, self.float_digits.create, {
|
|
'digits': 1,
|
|
'float': 1.11,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.float_digits.write,
|
|
[float6], {
|
|
'float': 1.11,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.float_digits.write,
|
|
[float6], {
|
|
'digits': 0,
|
|
})
|
|
|
|
float7 = self.float.create({
|
|
'float': 0.123456789012345,
|
|
})
|
|
self.assertEqual(float7.float, 0.123456789012345)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0040numeric(self):
|
|
'''
|
|
Test Numeric.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
numeric1 = self.numeric.create({
|
|
'numeric': Decimal('1.1'),
|
|
})
|
|
self.assert_(numeric1)
|
|
self.assertEqual(numeric1.numeric, Decimal('1.1'))
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '!=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '!=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'in', [Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'in', [Decimal('0')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'in', []),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'not in', [Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'not in', [Decimal('0')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'not in', []),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<=', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<=', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '<=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>=', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>=', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '>=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numeric2 = self.numeric.create({
|
|
'numeric': Decimal('0'),
|
|
})
|
|
self.assert_(numeric2)
|
|
self.assertEqual(numeric2.numeric, Decimal('0'))
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', '=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [numeric2])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'in', [Decimal('0'), Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1, numeric2])
|
|
|
|
numerics = self.numeric.search([
|
|
('numeric', 'not in', [Decimal('0'), Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numeric3 = self.numeric.create({})
|
|
self.assert_(numeric3)
|
|
self.assertEqual(numeric3.numeric, None)
|
|
|
|
numeric4 = self.numeric_default.create({})
|
|
self.assert_(numeric4)
|
|
self.assertEqual(numeric4.numeric, Decimal('5.5'))
|
|
|
|
self.numeric.write([numeric1], {
|
|
'numeric': Decimal('0'),
|
|
})
|
|
self.assertEqual(numeric1.numeric, Decimal('0'))
|
|
|
|
self.numeric.write([numeric2], {
|
|
'numeric': Decimal('1.1'),
|
|
})
|
|
self.assertEqual(numeric2.numeric, Decimal('1.1'))
|
|
|
|
self.assertRaises(Exception, self.numeric.create, {
|
|
'numeric': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.numeric.write, [numeric1], {
|
|
'numeric': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.numeric_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
numeric5 = self.numeric_required.create({
|
|
'numeric': Decimal(0),
|
|
})
|
|
self.assertEqual(numeric5.numeric, 0)
|
|
|
|
numeric6 = self.numeric_digits.create({
|
|
'digits': 1,
|
|
'numeric': Decimal('1.1'),
|
|
})
|
|
self.assert_(numeric6)
|
|
|
|
self.assertRaises(Exception, self.numeric_digits.create, {
|
|
'digits': 1,
|
|
'numeric': Decimal('1.11'),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.numeric_digits.write,
|
|
[numeric6], {
|
|
'numeric': Decimal('1.11'),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.numeric_digits.write,
|
|
[numeric6], {
|
|
'numeric': Decimal('0.10000000000000001'),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.numeric_digits.write,
|
|
[numeric6], {
|
|
'digits': 0,
|
|
})
|
|
|
|
numeric7 = self.numeric.create({
|
|
'numeric': Decimal('0.1234567890123456789'),
|
|
})
|
|
self.assertEqual(numeric7.numeric,
|
|
Decimal('0.1234567890123456789'))
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0050char(self):
|
|
'''
|
|
Test Char.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
for char in (self.char_translate, self.char):
|
|
char1 = char.create({
|
|
'char': 'Test',
|
|
})
|
|
self.assert_(char1)
|
|
self.assertEqual(char1.char, 'Test')
|
|
|
|
chars = char.search([
|
|
('char', '=', 'Test'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', '=', 'Foo'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', '=', None),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', '!=', 'Test'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', '!=', 'Foo'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', '!=', None),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'in', ['Test']),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'in', ['Foo']),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'in', [None]),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'in', []),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not in', ['Test']),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not in', ['Foo']),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'not in', [None]),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'not in', []),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'like', 'Test'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'like', 'T%'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'like', 'Foo'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'like', 'F%'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'ilike', 'test'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'ilike', 't%'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'ilike', 'foo'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'ilike', 'f%'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not like', 'Test'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not like', 'T%'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not like', 'Foo'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'not like', 'F%'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'not ilike', 'test'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not ilike', 't%'),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
chars = char.search([
|
|
('char', 'not ilike', 'foo'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
chars = char.search([
|
|
('char', 'not ilike', 'f%'),
|
|
])
|
|
self.assertEqual(chars, [char1])
|
|
|
|
char2 = char.create({
|
|
'char': None,
|
|
})
|
|
self.assert_(char2)
|
|
self.assertEqual(char2.char, None)
|
|
|
|
chars = char.search([
|
|
('char', '=', None),
|
|
])
|
|
self.assertEqual(chars, [char2])
|
|
|
|
chars = char.search([
|
|
('char', 'in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(chars, [char1, char2])
|
|
|
|
chars = char.search([
|
|
('char', 'not in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(chars, [])
|
|
|
|
char3 = self.char.create({})
|
|
self.assert_(char3)
|
|
self.assertEqual(char3.char, None)
|
|
|
|
char4 = self.char_default.create({})
|
|
self.assert_(char4)
|
|
self.assertEqual(char4.char, 'Test')
|
|
|
|
self.char.write([char1], {
|
|
'char': None,
|
|
})
|
|
self.assertEqual(char1.char, None)
|
|
|
|
self.char.write([char2], {
|
|
'char': 'Test',
|
|
})
|
|
self.assertEqual(char2.char, 'Test')
|
|
|
|
self.assertRaises(Exception, self.char_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
self.assertRaises(Exception, self.char_required.create, {
|
|
'char': '',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
char5 = self.char_required.create({
|
|
'char': 'Test',
|
|
})
|
|
self.assert_(char5)
|
|
|
|
char6 = self.char_size.create({
|
|
'char': 'Test',
|
|
})
|
|
self.assert_(char6)
|
|
|
|
self.assertRaises(Exception, self.char_size.create, {
|
|
'char': 'foobar',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.char_size.write, [char6], {
|
|
'char': 'foobar',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
char7 = self.char.create({
|
|
'char': u'é',
|
|
})
|
|
self.assert_(char7)
|
|
self.assertEqual(char7.char, u'é')
|
|
|
|
chars = self.char.search([
|
|
('char', '=', u'é'),
|
|
])
|
|
self.assertEqual(chars, [char7])
|
|
|
|
self.char.write([char7], {
|
|
'char': 'é',
|
|
})
|
|
self.assertEqual(char7.char, u'é')
|
|
|
|
chars = self.char.search([
|
|
('char', '=', 'é'),
|
|
])
|
|
self.assertEqual(chars, [char7])
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0060text(self):
|
|
'''
|
|
Test Text.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
for text in (self.text_translate, self.text):
|
|
text1 = text.create({
|
|
'text': 'Test',
|
|
})
|
|
self.assert_(text1)
|
|
self.assertEqual(text1.text, 'Test')
|
|
|
|
texts = text.search([
|
|
('text', '=', 'Test'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', '=', 'Foo'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', '=', None),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', '!=', 'Test'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', '!=', 'Foo'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', '!=', None),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'in', ['Test']),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'in', ['Foo']),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'in', [None]),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'in', []),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not in', ['Test']),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not in', ['Foo']),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'not in', [None]),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'not in', []),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'like', 'Test'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'like', 'T%'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'like', 'Foo'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'like', 'F%'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'ilike', 'test'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'ilike', 't%'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'ilike', 'foo'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'ilike', 'f%'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not like', 'Test'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not like', 'T%'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not like', 'Foo'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'not like', 'F%'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'not ilike', 'test'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not ilike', 't%'),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
texts = text.search([
|
|
('text', 'not ilike', 'foo'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
texts = text.search([
|
|
('text', 'not ilike', 'f%'),
|
|
])
|
|
self.assertEqual(texts, [text1])
|
|
|
|
text2 = text.create({
|
|
'text': None,
|
|
})
|
|
self.assert_(text2)
|
|
self.assertEqual(text2.text, None)
|
|
|
|
texts = text.search([
|
|
('text', '=', None),
|
|
])
|
|
self.assertEqual(texts, [text2])
|
|
|
|
texts = text.search([
|
|
('text', 'in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(texts, [text1, text2])
|
|
|
|
texts = text.search([
|
|
('text', 'not in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(texts, [])
|
|
|
|
text3 = self.text.create({})
|
|
self.assert_(text3)
|
|
self.assertEqual(text3.text, None)
|
|
|
|
text4 = self.text_default.create({})
|
|
self.assert_(text4)
|
|
self.assertEqual(text4.text, 'Test')
|
|
|
|
self.text.write([text1], {
|
|
'text': None,
|
|
})
|
|
self.assertEqual(text1.text, None)
|
|
|
|
self.text.write([text2], {
|
|
'text': 'Test',
|
|
})
|
|
self.assertEqual(text2.text, 'Test')
|
|
|
|
self.assertRaises(Exception, self.text_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
text5 = self.text_required.create({
|
|
'text': 'Test',
|
|
})
|
|
self.assert_(text5)
|
|
|
|
text6 = self.text_size.create({
|
|
'text': 'Test',
|
|
})
|
|
self.assert_(text6)
|
|
|
|
self.assertRaises(Exception, self.text_size.create, {
|
|
'text': 'foobar',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.text_size.write, [text6], {
|
|
'text': 'foobar',
|
|
})
|
|
|
|
text7 = self.text.create({
|
|
'text': 'Foo\nBar',
|
|
})
|
|
self.assert_(text7)
|
|
|
|
text8 = self.text.create({
|
|
'text': u'é',
|
|
})
|
|
self.assert_(text8)
|
|
self.assertEqual(text8.text, u'é')
|
|
|
|
texts = self.text.search([
|
|
('text', '=', u'é'),
|
|
])
|
|
self.assertEqual(texts, [text8])
|
|
|
|
self.text.write([text8], {
|
|
'text': 'é',
|
|
})
|
|
self.assertEqual(text8.text, u'é')
|
|
|
|
texts = self.text.search([
|
|
('text', '=', 'é'),
|
|
])
|
|
self.assertEqual(texts, [text8])
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0070sha(self):
|
|
'''
|
|
Test Sha.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
sha1 = self.sha.create({
|
|
'sha': 'Test',
|
|
})
|
|
self.assert_(sha1)
|
|
self.assertEqual(sha1.sha,
|
|
'640ab2bae07bedc4c163f679a746f7ab7fb5d1fa')
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', 'Test'),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', 'Foo'),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', None),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', '!=', 'Test'),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', '!=', 'Foo'),
|
|
])
|
|
self.assert_(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', '!=', None),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'in', ['Test']),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'in', ['Foo']),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'in', [None]),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'in', []),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not in', ['Test']),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not in', ['Foo']),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not in', [None]),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not in', []),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'like', 'Test'),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'like', 'Foo'),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'ilike', 'Test'),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'ilike', 'foo'),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not like', 'Test'),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not like', 'Foo'),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not ilike', 'foo'),
|
|
])
|
|
self.assertEqual(sha, [sha1])
|
|
|
|
sha2 = self.sha.create({
|
|
'sha': None,
|
|
})
|
|
self.assert_(sha2)
|
|
self.assertEqual(sha2.sha, None)
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', None),
|
|
])
|
|
self.assertEqual(sha, [sha2])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(sha, [sha1, sha2])
|
|
|
|
sha = self.sha.search([
|
|
('sha', 'not in', [None, 'Test']),
|
|
])
|
|
self.assertEqual(sha, [])
|
|
|
|
sha3 = self.sha.create({})
|
|
self.assert_(sha3)
|
|
self.assertEqual(sha3.sha, None)
|
|
|
|
sha4 = self.sha_default.create({})
|
|
self.assert_(sha4)
|
|
self.assertEqual(sha4.sha,
|
|
'ba79baeb9f10896a46ae74715271b7f586e74640')
|
|
|
|
self.sha.write([sha1], {
|
|
'sha': None,
|
|
})
|
|
self.assertEqual(sha1.sha, None)
|
|
|
|
self.sha.write([sha2], {
|
|
'sha': 'Test',
|
|
})
|
|
self.assertEqual(sha2.sha,
|
|
'640ab2bae07bedc4c163f679a746f7ab7fb5d1fa')
|
|
|
|
self.assertRaises(Exception, self.sha_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
sha5 = self.sha_required.create({
|
|
'sha': 'Test',
|
|
})
|
|
self.assert_(sha5)
|
|
|
|
sha6 = self.sha.create({
|
|
'sha': u'é',
|
|
})
|
|
self.assert_(sha6)
|
|
self.assertEqual(sha6.sha,
|
|
u'bf15be717ac1b080b4f1c456692825891ff5073d')
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', u'é'),
|
|
])
|
|
self.assertEqual(sha, [sha6])
|
|
|
|
self.sha.write([sha6], {
|
|
'sha': 'é',
|
|
})
|
|
self.assertEqual(sha6.sha,
|
|
u'bf15be717ac1b080b4f1c456692825891ff5073d')
|
|
|
|
sha = self.sha.search([
|
|
('sha', '=', 'é'),
|
|
])
|
|
self.assertEqual(sha, [sha6])
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0080date(self):
|
|
'''
|
|
Test Date.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
today = datetime.date(2009, 1, 1)
|
|
tomorrow = today + datetime.timedelta(1)
|
|
yesterday = today - datetime.timedelta(1)
|
|
default_date = datetime.date(2000, 1, 1)
|
|
|
|
date1 = self.date.create({
|
|
'date': today,
|
|
})
|
|
self.assert_(date1)
|
|
self.assertEqual(date1.date, today)
|
|
|
|
dates = self.date.search([
|
|
('date', '=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '=', None),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '!=', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '!=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '!=', None),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', 'in', [today]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', 'in', [tomorrow]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', 'in', [None]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', 'in', []),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', 'not in', [today]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', 'not in', [tomorrow]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', 'not in', [None]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', 'not in', []),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '<', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '<', yesterday),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '<', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '<=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '<=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '<=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '>', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '>', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '>', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '>=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = self.date.search([
|
|
('date', '>=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = self.date.search([
|
|
('date', '>=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
date2 = self.date.create({
|
|
'date': yesterday,
|
|
})
|
|
self.assert_(date2)
|
|
self.assertEqual(date2.date, yesterday)
|
|
|
|
dates = self.date.search([
|
|
('date', '=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date2])
|
|
|
|
dates = self.date.search([
|
|
('date', 'in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(dates, [date1, date2])
|
|
|
|
dates = self.date.search([
|
|
('date', 'not in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
date3 = self.date.create({})
|
|
self.assert_(date3)
|
|
self.assertEqual(date3.date, None)
|
|
|
|
date4 = self.date_default.create({})
|
|
self.assert_(date4)
|
|
self.assertEqual(date4.date, default_date)
|
|
|
|
self.date.write([date1], {
|
|
'date': yesterday,
|
|
})
|
|
self.assertEqual(date1.date, yesterday)
|
|
|
|
self.date.write([date2], {
|
|
'date': today,
|
|
})
|
|
self.assertEqual(date2.date, today)
|
|
|
|
self.assertRaises(Exception, self.date.create, {
|
|
'date': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.write, [date1], {
|
|
'date': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.create, {
|
|
'date': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.write, [date1], {
|
|
'date': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.create, {
|
|
'date': datetime.datetime.now(),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.write, [date1], {
|
|
'date': datetime.datetime.now(),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.create, {
|
|
'date': '2009-13-01',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.date.write, [date1], {
|
|
'date': '2009-02-29',
|
|
})
|
|
|
|
date5 = self.date.create({
|
|
'date': '2009-01-01',
|
|
})
|
|
self.assert_(date5)
|
|
self.assertEqual(date5.date, datetime.date(2009, 1, 1))
|
|
|
|
self.assertRaises(Exception, self.date_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
date6 = self.date_required.create({
|
|
'date': today,
|
|
})
|
|
self.assert_(date6)
|
|
|
|
date7 = self.date.create({
|
|
'date': None,
|
|
})
|
|
self.assert_(date7)
|
|
|
|
date8 = self.date.create({
|
|
'date': None,
|
|
})
|
|
self.assert_(date8)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0090datetime(self):
|
|
'''
|
|
Test DateTime.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
today = datetime.datetime(2009, 1, 1, 12, 0, 0)
|
|
tomorrow = today + datetime.timedelta(1)
|
|
yesterday = today - datetime.timedelta(1)
|
|
default_datetime = datetime.datetime(2000, 1, 1, 12, 0, 0)
|
|
|
|
datetime1 = self.datetime.create({
|
|
'datetime': today,
|
|
})
|
|
self.assert_(datetime1)
|
|
self.assertEqual(datetime1.datetime, today)
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '=', None),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '!=', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '!=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '!=', None),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'in', [today]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'in', [tomorrow]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'in', [None]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'in', []),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'not in', [today]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'not in', [tomorrow]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'not in', [None]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'not in', []),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '<=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '>=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetime2 = self.datetime.create({
|
|
'datetime': yesterday,
|
|
})
|
|
self.assert_(datetime2)
|
|
self.assertEqual(datetime2.datetime, yesterday)
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', '=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime2])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1, datetime2])
|
|
|
|
datetimes = self.datetime.search([
|
|
('datetime', 'not in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetime3 = self.datetime.create({})
|
|
self.assert_(datetime3)
|
|
self.assertEqual(datetime3.datetime, None)
|
|
|
|
datetime4 = self.datetime_default.create({})
|
|
self.assert_(datetime4)
|
|
self.assertEqual(datetime4.datetime, default_datetime)
|
|
|
|
self.datetime.write([datetime1], {
|
|
'datetime': yesterday,
|
|
})
|
|
self.assertEqual(datetime1.datetime, yesterday)
|
|
|
|
self.datetime.write([datetime2], {
|
|
'datetime': today,
|
|
})
|
|
self.assertEqual(datetime2.datetime, today)
|
|
|
|
self.assertRaises(Exception, self.datetime.create, {
|
|
'datetime': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.write, [datetime1],
|
|
{
|
|
'datetime': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.create, {
|
|
'datetime': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.write, [datetime1],
|
|
{
|
|
'datetime': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.create, {
|
|
'datetime': datetime.date.today(),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.write, [datetime1],
|
|
{
|
|
'datetime': datetime.date.today(),
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.create, {
|
|
'datetime': '2009-13-01 12:30:00',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.write, [datetime1],
|
|
{
|
|
'datetime': '2009-02-29 12:30:00',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.datetime.write, [datetime1],
|
|
{
|
|
'datetime': '2009-01-01 25:00:00',
|
|
})
|
|
|
|
datetime5 = self.datetime.create({
|
|
'datetime': '2009-01-01 12:00:00',
|
|
})
|
|
self.assert_(datetime5)
|
|
self.assertEqual(datetime5.datetime,
|
|
datetime.datetime(2009, 1, 1, 12, 0, 0))
|
|
|
|
self.assertRaises(Exception, self.datetime_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
datetime6 = self.datetime_required.create({
|
|
'datetime': today,
|
|
})
|
|
self.assert_(datetime6)
|
|
|
|
datetime7 = self.datetime.create({
|
|
'datetime': None,
|
|
})
|
|
self.assert_(datetime7)
|
|
|
|
datetime8 = self.datetime.create({
|
|
'datetime': None,
|
|
})
|
|
self.assert_(datetime8)
|
|
|
|
datetime9 = self.datetime.create({
|
|
'datetime': today.replace(microsecond=1),
|
|
})
|
|
self.assert_(datetime9)
|
|
self.assertEqual(datetime9.datetime, today)
|
|
|
|
# Test format
|
|
self.assert_(self.datetime_format.create({
|
|
'datetime': datetime.datetime(2009, 1, 1, 12, 30),
|
|
}))
|
|
self.assertRaises(Exception, self.datetime_format.create, {
|
|
'datetime': datetime.datetime(2009, 1, 1, 12, 30, 25),
|
|
})
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0100time(self):
|
|
'''
|
|
Test Time.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
pre_evening = datetime.time(16, 30)
|
|
evening = datetime.time(18, 45, 3)
|
|
night = datetime.time(20, 00)
|
|
default_time = datetime.time(16, 30)
|
|
|
|
time1 = self.time.create({
|
|
'time': evening,
|
|
})
|
|
self.assert_(time1)
|
|
self.assertEqual(time1.time, evening)
|
|
|
|
times = self.time.search([
|
|
('time', '=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '=', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '=', None),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '!=', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '!=', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '!=', None),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', 'in', [evening]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', 'in', [night]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', 'in', [None]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', 'in', []),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', 'not in', [evening]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', 'not in', [night]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', 'not in', [None]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', 'not in', []),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '<', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '<', pre_evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '<', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '<=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '<=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '<=', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '>', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '>', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '>', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '>=', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = self.time.search([
|
|
('time', '>=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = self.time.search([
|
|
('time', '>=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
time2 = self.time.create({
|
|
'time': pre_evening,
|
|
})
|
|
self.assert_(time2)
|
|
self.assertEqual(time2.time, pre_evening)
|
|
|
|
times = self.time.search([
|
|
('time', '=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time2])
|
|
|
|
times = self.time.search([
|
|
('time', 'in', [pre_evening, evening]),
|
|
])
|
|
self.assertEqual(times, [time1, time2])
|
|
|
|
times = self.time.search([
|
|
('time', 'not in', [pre_evening, evening]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
time3 = self.time.create({})
|
|
self.assert_(time3)
|
|
self.assertEqual(time3.time, None)
|
|
|
|
time4 = self.time_default.create({})
|
|
self.assert_(time4)
|
|
self.assertEqual(time4.time, default_time)
|
|
|
|
self.time.write([time1], {
|
|
'time': pre_evening,
|
|
})
|
|
self.assertEqual(time1.time, pre_evening)
|
|
|
|
self.time.write([time2], {
|
|
'time': evening,
|
|
})
|
|
self.assertEqual(time2.time, evening)
|
|
|
|
self.assertRaises(Exception, self.time.create, {
|
|
'time': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.time.write, [time1],
|
|
{
|
|
'time': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, self.time.create, {
|
|
'time': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.time.write, [time1],
|
|
{
|
|
'time': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, self.time.write, [time1],
|
|
{
|
|
'time': '25:00:00',
|
|
})
|
|
|
|
time5 = self.time.create({
|
|
'time': '12:00:00',
|
|
})
|
|
self.assert_(time5)
|
|
self.assertEqual(time5.time, datetime.time(12, 0))
|
|
|
|
self.assertRaises(Exception, self.time_required.create, {})
|
|
transaction.cursor.rollback()
|
|
|
|
time6 = self.time_required.create({
|
|
'time': evening,
|
|
})
|
|
self.assert_(time6)
|
|
|
|
time7 = self.time.create({
|
|
'time': None,
|
|
})
|
|
self.assert_(time7)
|
|
|
|
time8 = self.time.create({
|
|
'time': False,
|
|
})
|
|
self.assert_(time8)
|
|
|
|
time9 = self.time.create({
|
|
'time': evening.replace(microsecond=1),
|
|
})
|
|
self.assert_(time9)
|
|
self.assertEqual(time9.time, evening)
|
|
|
|
# Test format
|
|
self.assert_(self.time_format.create({
|
|
'time': datetime.time(12, 30),
|
|
}))
|
|
self.assertRaises(Exception, self.time_format.create, {
|
|
'time': datetime.time(12, 30, 25),
|
|
})
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0110one2one(self):
|
|
'''
|
|
Test One2One.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
target1 = self.one2one_target.create({
|
|
'name': 'target1',
|
|
})
|
|
one2one1 = self.one2one.create({
|
|
'name': 'origin1',
|
|
'one2one': target1.id,
|
|
})
|
|
self.assert_(one2one1)
|
|
self.assertEqual(one2one1.one2one, target1)
|
|
|
|
self.assertEqual(self.one2one.read([one2one1.id],
|
|
['one2one.name'])[0]['one2one.name'], 'target1')
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', 'in', [target1.id]),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', 'in', [0]),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', 'not in', [target1.id]),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', 'not in', [0]),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one.name', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one.name', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2one2 = self.one2one.create({
|
|
'name': 'origin2',
|
|
})
|
|
self.assert_(one2one2)
|
|
self.assertEqual(one2one2.one2one, None)
|
|
|
|
one2ones = self.one2one.search([
|
|
('one2one', '=', None),
|
|
])
|
|
self.assertEqual(one2ones, [one2one2])
|
|
|
|
target2 = self.one2one_target.create({
|
|
'name': 'target2',
|
|
})
|
|
self.one2one.write([one2one2], {
|
|
'one2one': target2.id,
|
|
})
|
|
self.assertEqual(one2one2.one2one, target2)
|
|
|
|
self.one2one.write([one2one2], {
|
|
'one2one': None,
|
|
})
|
|
self.assertEqual(one2one2.one2one, None)
|
|
|
|
self.assertRaises(Exception, self.one2one.create, {
|
|
'name': 'one2one3',
|
|
'one2one': target1.id,
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
self.assertRaises(Exception, self.one2one.write, [one2one2], {
|
|
'one2one': target1.id,
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
self.assertRaises(Exception, self.one2one_required.create, {
|
|
'name': 'one2one3',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
target3 = self.one2one_target.create({
|
|
'name': 'target3',
|
|
})
|
|
|
|
one2one3 = self.one2one_required.create({
|
|
'name': 'one2one3',
|
|
'one2one': target3.id,
|
|
})
|
|
self.assert_(one2one3)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0120one2many(self):
|
|
'''
|
|
Test One2Many.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
for one2many, one2many_target in (
|
|
(self.one2many, self.one2many_target),
|
|
(self.one2many_reference, self.one2many_reference_target),
|
|
):
|
|
one2many1 = one2many.create({
|
|
'name': 'origin1',
|
|
'targets': [
|
|
('create', {
|
|
'name': 'target1',
|
|
}),
|
|
],
|
|
})
|
|
self.assert_(one2many1)
|
|
|
|
self.assertEqual(len(one2many1.targets), 1)
|
|
target1, = one2many1.targets
|
|
|
|
# Try with target1 stored in cache
|
|
target1 = one2many_target(target1.id)
|
|
target1.origin
|
|
one2many1 = one2many(one2many1)
|
|
self.assertEqual(one2many1.targets, (target1,))
|
|
|
|
one2manys = one2many.search([
|
|
('targets', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2manys, [one2many1])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2manys, [])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', 'in', [target1.id]),
|
|
])
|
|
self.assertEqual(one2manys, [one2many1])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', 'in', [0]),
|
|
])
|
|
self.assertEqual(one2manys, [])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', 'not in', (target1.id,)),
|
|
])
|
|
self.assertEqual(one2manys, [])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', 'not in', [0]),
|
|
])
|
|
self.assertEqual(one2manys, [one2many1])
|
|
|
|
one2manys = one2many.search([
|
|
('targets.name', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2manys, [one2many1])
|
|
|
|
one2manys = one2many.search([
|
|
('targets.name', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2manys, [])
|
|
|
|
one2many2 = one2many.create({
|
|
'name': 'origin2',
|
|
})
|
|
self.assert_(one2many2)
|
|
|
|
self.assertEqual(one2many2.targets, ())
|
|
|
|
one2manys = one2many.search([
|
|
('targets', '=', None),
|
|
])
|
|
self.assertEqual(one2manys, [one2many2])
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('write', [target1.id], {
|
|
'name': 'target1bis',
|
|
}),
|
|
],
|
|
})
|
|
self.assertEqual(target1.name, 'target1bis')
|
|
|
|
target2 = one2many_target.create({
|
|
'name': 'target2',
|
|
})
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('add', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets,
|
|
(target1, target2))
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('unlink', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, (target1,))
|
|
target2, = one2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assert_(target2)
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('unlink_all',),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, ())
|
|
targets = one2many_target.search([
|
|
('id', 'in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(targets, [target1, target2])
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('set', [target1.id, target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets,
|
|
(target1, target2))
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('delete', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, (target1,))
|
|
targets = one2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('delete_all',),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, ())
|
|
targets = one2many_target.search([
|
|
('id', '=', target1.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
self.assertRaises(Exception, self.one2many_required.create, {
|
|
'name': 'origin3',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
origin3_id = self.one2many_required.create({
|
|
'name': 'origin3',
|
|
'targets': [
|
|
('create', {
|
|
'name': 'target3',
|
|
}),
|
|
],
|
|
})
|
|
self.assert_(origin3_id)
|
|
|
|
self.one2many_size.create({
|
|
'targets': [('create', {})] * 3,
|
|
})
|
|
self.assertRaises(Exception, self.one2many_size.create, {
|
|
'targets': [('create', {})] * 4,
|
|
})
|
|
self.one2many_size_pyson.create({
|
|
'limit': 4,
|
|
'targets': [('create', {})] * 4,
|
|
})
|
|
self.assertRaises(Exception, self.one2many_size_pyson.create, {
|
|
'limit': 2,
|
|
'targets': [('create', {})] * 4,
|
|
})
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0130many2many(self):
|
|
'''
|
|
Test Many2Many.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
for many2many, many2many_target in (
|
|
(self.many2many, self.many2many_target),
|
|
(self.many2many_reference,
|
|
self.many2many_reference_target),
|
|
):
|
|
many2many1 = many2many.create({
|
|
'name': 'origin1',
|
|
'targets': [
|
|
('create', {
|
|
'name': 'target1',
|
|
}),
|
|
],
|
|
})
|
|
self.assert_(many2many1)
|
|
|
|
self.assertEqual(len(many2many1.targets), 1)
|
|
target1, = many2many1.targets
|
|
|
|
many2manys = many2many.search([
|
|
('targets', '=', 'target1'),
|
|
])
|
|
self.assertEqual(many2manys, [many2many1])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(many2manys, [])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', 'in', [target1.id]),
|
|
])
|
|
self.assertEqual(many2manys, [many2many1])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', 'in', [0]),
|
|
])
|
|
self.assertEqual(many2manys, [])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', 'not in', [target1.id]),
|
|
])
|
|
self.assertEqual(many2manys, [])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', 'not in', [0]),
|
|
])
|
|
self.assertEqual(many2manys, [many2many1])
|
|
|
|
many2manys = many2many.search([
|
|
('targets.name', '=', 'target1'),
|
|
])
|
|
self.assertEqual(many2manys, [many2many1])
|
|
|
|
many2manys = many2many.search([
|
|
('targets.name', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(many2manys, [])
|
|
|
|
many2many2 = many2many.create({
|
|
'name': 'origin2',
|
|
})
|
|
self.assert_(many2many2)
|
|
|
|
self.assertEqual(many2many2.targets, ())
|
|
|
|
many2manys = many2many.search([
|
|
('targets', '=', None),
|
|
])
|
|
self.assertEqual(many2manys, [many2many2])
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('write', [target1.id], {
|
|
'name': 'target1bis',
|
|
}),
|
|
],
|
|
})
|
|
self.assertEqual(target1.name, 'target1bis')
|
|
|
|
target2 = many2many_target.create({
|
|
'name': 'target2',
|
|
})
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('add', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets,
|
|
(target1, target2))
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('unlink', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, (target1,))
|
|
target2, = many2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assert_(target2)
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('unlink_all',),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, ())
|
|
targets = many2many_target.search([
|
|
('id', 'in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(targets, [target1, target2])
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('set', [target1.id, target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets,
|
|
(target1, target2))
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('delete', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, (target1,))
|
|
targets = many2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('delete_all',),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, ())
|
|
targets = many2many_target.search([
|
|
('id', '=', target1.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
self.assertRaises(Exception, self.many2many_required.create, {
|
|
'name': 'origin3',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
origin3_id = self.many2many_required.create({
|
|
'name': 'origin3',
|
|
'targets': [
|
|
('create', {
|
|
'name': 'target3',
|
|
}),
|
|
],
|
|
})
|
|
self.assert_(origin3_id)
|
|
|
|
size_targets = [
|
|
self.many2many_size_target.create({
|
|
'name': str(i),
|
|
}) for i in range(6)]
|
|
|
|
self.many2many_size.create({
|
|
'targets': [('set', size_targets[:5])],
|
|
})
|
|
self.assertRaises(Exception, self.many2many_size.create, {
|
|
'targets': [('set', size_targets)],
|
|
})
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0140reference(self):
|
|
'''
|
|
Test Reference.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
target1 = self.reference_target.create({
|
|
'name': 'target1',
|
|
})
|
|
reference1 = self.reference.create({
|
|
'name': 'reference1',
|
|
'reference': str(target1),
|
|
})
|
|
self.assert_(reference1)
|
|
|
|
self.assertEqual(reference1.reference, target1)
|
|
|
|
references = self.reference.search([
|
|
('reference', '=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = self.reference.search([
|
|
('reference', '=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = self.reference.search([
|
|
('reference', '=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = self.reference.search([
|
|
('reference', '!=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = self.reference.search([
|
|
('reference', '!=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'in', [str(target1)]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'in',
|
|
[('test.reference.target', target1.id)]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'in', [None]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'not in', [str(target1)]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'not in',
|
|
[('test.reference.target', target1.id)]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = self.reference.search([
|
|
('reference', 'not in', [None]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
reference2 = self.reference.create({
|
|
'name': 'reference2',
|
|
})
|
|
self.assert_(reference2)
|
|
|
|
self.assertEqual(reference2.reference, None)
|
|
|
|
references = self.reference.search([
|
|
('reference', '=', None),
|
|
])
|
|
self.assertEqual(references, [reference2])
|
|
|
|
target2 = self.reference_target.create({
|
|
'name': 'target2',
|
|
})
|
|
|
|
self.reference.write([reference2], {
|
|
'reference': str(target2),
|
|
})
|
|
self.assertEqual(reference2.reference, target2)
|
|
|
|
self.reference.write([reference2], {
|
|
'reference': None,
|
|
})
|
|
self.assertEqual(reference2.reference, None)
|
|
|
|
self.reference.write([reference2], {
|
|
'reference': ('test.reference.target', target2.id),
|
|
})
|
|
self.assertEqual(reference2.reference, target2)
|
|
|
|
reference3 = self.reference.create({
|
|
'name': 'reference3',
|
|
'reference': ('test.reference.target', target1.id),
|
|
})
|
|
self.assert_(reference3)
|
|
|
|
self.assertRaises(Exception, self.reference_required.create, {
|
|
'name': 'reference4',
|
|
})
|
|
transaction.cursor.rollback()
|
|
|
|
target4 = self.reference_target.create({
|
|
'name': 'target4_id',
|
|
})
|
|
|
|
reference4 = self.reference_required.create({
|
|
'name': 'reference4',
|
|
'reference': str(target4),
|
|
})
|
|
self.assert_(reference4)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
def test0150property(self):
|
|
'''
|
|
Test Property with supported field types.
|
|
'''
|
|
with Transaction().start(DB_NAME, USER,
|
|
context=CONTEXT) as transaction:
|
|
|
|
# Test Char
|
|
prop_a = self.property_.create({'char': 'Test'})
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.char, 'Test')
|
|
|
|
prop_b = self.property_.create({})
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.char, None)
|
|
|
|
prop_c = self.property_.create({'char': 'FooBar'})
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.char, 'FooBar')
|
|
|
|
props = self.property_.search([('char', '=', 'Test')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([('char', '=', None)])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
props = self.property_.search([('char', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_c])
|
|
|
|
props = self.property_.search([('char', 'like', 'Tes%')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([('char', 'like', '%Bar')])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = self.property_.search([('char', 'not like', 'Tes%')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = self.property_.search([('char', 'ilike', 'tes%')])
|
|
self.assert_(props, [prop_a])
|
|
|
|
props = self.property_.search([('char', 'ilike', '%bar')])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = self.property_.search([('char', 'not ilike', 'tes%')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = self.property_.search([('char', 'in', ['Test'])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([
|
|
('char', 'in', ['Test', 'FooBar'])])
|
|
self.assertEqual(props, [prop_a, prop_c])
|
|
|
|
props = self.property_.search([
|
|
('char', 'not in', ['Test', 'FooBar'])])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
# Test default value
|
|
property_field, = self.model_field.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'char'),
|
|
], limit=1)
|
|
self.ir_property.create({
|
|
'field': property_field.id,
|
|
'value': ',DEFAULT_VALUE',
|
|
})
|
|
|
|
prop_d = self.property_.create({})
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.char, 'DEFAULT_VALUE')
|
|
|
|
props = self.property_.search([('char', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_c, prop_d])
|
|
|
|
self.property_.write([prop_a], {'char': None})
|
|
self.assertEqual(prop_a.char, None)
|
|
|
|
self.property_.write([prop_b], {'char': 'Test'})
|
|
self.assertEqual(prop_b.char, 'Test')
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
# Test Many2One
|
|
char_a = self.char.create({'char': 'Test'})
|
|
self.assert_(char_a)
|
|
|
|
char_b = self.char.create({'char': 'FooBar'})
|
|
self.assert_(char_b)
|
|
|
|
prop_a = self.property_.create({'many2one': char_a.id})
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.many2one, char_a)
|
|
|
|
prop_b = self.property_.create({'many2one': char_b.id})
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.many2one, char_b)
|
|
|
|
prop_c = self.property_.create({})
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.many2one, None)
|
|
|
|
props = self.property_.search([('many2one', '=', char_a.id)])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([('many2one', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([('many2one', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
self.assertEqual(prop_a.many2one, char_a)
|
|
|
|
props = self.property_.search([
|
|
('many2one', 'in', [char_a.id, char_b.id])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([
|
|
('many2one', 'not in', [char_a.id, char_b.id])])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
self.property_.write([prop_b], {'many2one': char_a.id})
|
|
self.assertEqual(prop_b.many2one, char_a)
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
# Test Numeric
|
|
prop_a = self.property_.create({'numeric': Decimal('1.1')})
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.numeric, Decimal('1.1'))
|
|
|
|
prop_b = self.property_.create({'numeric': Decimal('2.6')})
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.numeric, Decimal('2.6'))
|
|
|
|
prop_c = self.property_.create({})
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.numeric, None)
|
|
|
|
props = self.property_.search([('numeric', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([('numeric', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '!=', Decimal('1.1'))])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '<', Decimal('2.6')),
|
|
])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '<=', Decimal('2.6'))])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '>', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
props = self.property_.search([
|
|
('numeric', '>=', Decimal('1.1'))])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([
|
|
('numeric', 'in', [Decimal('1.1')])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([
|
|
('numeric', 'in', [Decimal('1.1'), Decimal('2.6')])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([
|
|
('numeric', 'not in', [Decimal('1.1')])])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = self.property_.search([
|
|
('numeric', 'not in', [Decimal('1.1'), Decimal('2.6')])])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
# Test default value
|
|
property_field, = self.model_field.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'numeric'),
|
|
], limit=1)
|
|
self.ir_property.create({
|
|
'field': property_field.id,
|
|
'value': ',3.7',
|
|
})
|
|
|
|
prop_d = self.property_.create({})
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.numeric, Decimal('3.7'))
|
|
|
|
self.property_.write([prop_a], {'numeric': None})
|
|
self.assertEqual(prop_a.numeric, None)
|
|
|
|
self.property_.write([prop_b], {'numeric': Decimal('3.11')})
|
|
self.assertEqual(prop_b.numeric, Decimal('3.11'))
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
# Test Selection
|
|
prop_a = self.property_.create({'selection': 'option_a'})
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.selection, 'option_a')
|
|
|
|
prop_b = self.property_.create({'selection': 'option_b'})
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.selection, 'option_b')
|
|
|
|
prop_c = self.property_.create({})
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.selection, None)
|
|
|
|
props = self.property_.search([('selection', '=', 'option_a')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([('selection', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([('selection', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = self.property_.search([('selection', '!=', 'option_a')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = self.property_.search([
|
|
('selection', 'in', ['option_a'])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = self.property_.search([
|
|
('selection', 'in', ['option_a', 'option_b'])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = self.property_.search([
|
|
('selection', 'not in', ['option_a'])])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
# Test default value
|
|
property_field, = self.model_field.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'selection'),
|
|
], limit=1)
|
|
self.ir_property.create({
|
|
'field': property_field.id,
|
|
'value': ',option_a',
|
|
})
|
|
|
|
prop_d = self.property_.create({})
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.selection, 'option_a')
|
|
|
|
self.property_.write([prop_a], {'selection': None})
|
|
self.assertEqual(prop_a.selection, None)
|
|
|
|
self.property_.write([prop_c], {'selection': 'option_b'})
|
|
self.assertEqual(prop_c.selection, 'option_b')
|
|
|
|
transaction.cursor.rollback()
|
|
|
|
|
|
def suite():
|
|
return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase)
|
|
|
|
if __name__ == '__main__':
|
|
suite = suite()
|
|
unittest.TextTestRunner(verbosity=2).run(suite)
|