3639 lines
111 KiB
Python
3639 lines
111 KiB
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 install_module, with_transaction
|
|
from trytond.transaction import Transaction
|
|
from trytond.exceptions import UserError
|
|
from trytond.model import fields
|
|
from trytond.pool import Pool
|
|
|
|
|
|
class FieldsTestCase(unittest.TestCase):
|
|
'Test Fields'
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
install_module('tests')
|
|
|
|
@with_transaction()
|
|
def test_boolean(self):
|
|
'Test Boolean'
|
|
pool = Pool()
|
|
Boolean = pool.get('test.boolean')
|
|
BooleanDefault = pool.get('test.boolean_default')
|
|
|
|
boolean1, = Boolean.create([{
|
|
'boolean': True,
|
|
}])
|
|
self.assert_(boolean1)
|
|
self.assertEqual(boolean1.boolean, True)
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', '=', True),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', '!=', True),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'in', [True]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'in', [False]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'not in', [True]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'not in', [False]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
boolean2, = Boolean.create([{
|
|
'boolean': False,
|
|
}])
|
|
self.assert_(boolean2)
|
|
self.assertEqual(boolean2.boolean, False)
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', '=', False),
|
|
])
|
|
self.assertEqual(booleans, [boolean2])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'in', [True, False]),
|
|
])
|
|
self.assertEqual(booleans, [boolean1, boolean2])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', 'not in', [True, False]),
|
|
])
|
|
self.assertEqual(booleans, [])
|
|
|
|
boolean3, = Boolean.create([{}])
|
|
self.assert_(boolean3)
|
|
self.assertEqual(boolean3.boolean, False)
|
|
|
|
# Test search with NULL value
|
|
boolean4, = Boolean.create([{
|
|
'boolean': None,
|
|
}])
|
|
self.assert_(boolean4)
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', '=', False),
|
|
])
|
|
self.assertEqual(booleans,
|
|
[boolean2, boolean3, boolean4])
|
|
|
|
booleans = Boolean.search([
|
|
('boolean', '!=', False),
|
|
])
|
|
self.assertEqual(booleans, [boolean1])
|
|
|
|
boolean4, = BooleanDefault.create([{}])
|
|
self.assert_(boolean4)
|
|
self.assertTrue(boolean4.boolean)
|
|
|
|
Boolean.write([boolean1], {
|
|
'boolean': False,
|
|
})
|
|
self.assertEqual(boolean1.boolean, False)
|
|
|
|
Boolean.write([boolean2], {
|
|
'boolean': True,
|
|
})
|
|
self.assertEqual(boolean2.boolean, True)
|
|
|
|
@with_transaction()
|
|
def test_integer(self):
|
|
'Test Integer'
|
|
pool = Pool()
|
|
Integer = pool.get('test.integer')
|
|
IntegerDefault = pool.get('test.integer_default')
|
|
IntegerRequired = pool.get('test.integer_required')
|
|
transaction = Transaction()
|
|
|
|
integer1, = Integer.create([{
|
|
'integer': 1,
|
|
}])
|
|
self.assert_(integer1)
|
|
self.assertEqual(integer1.integer, 1)
|
|
|
|
integers = Integer.search([
|
|
('integer', '=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '=', 0),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '!=', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '!=', 0),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'in', [1]),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'in', [0]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'in', []),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'not in', [1]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'not in', [0]),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'not in', []),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<', 5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<', -5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<=', 5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<=', -5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '<=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>', 5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>', -5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>', 1),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>=', 5),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>=', -5),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integers = Integer.search([
|
|
('integer', '>=', 1),
|
|
])
|
|
self.assertEqual(integers, [integer1])
|
|
|
|
integer2, = Integer.create([{
|
|
'integer': 0,
|
|
}])
|
|
self.assert_(integer2)
|
|
self.assertEqual(integer2.integer, 0)
|
|
|
|
integers = Integer.search([
|
|
('integer', '=', 0),
|
|
])
|
|
self.assertEqual(integers, [integer2])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'in', [0, 1]),
|
|
])
|
|
self.assertEqual(integers, [integer1, integer2])
|
|
|
|
integers = Integer.search([
|
|
('integer', 'not in', [0, 1]),
|
|
])
|
|
self.assertEqual(integers, [])
|
|
|
|
integer3, = Integer.create([{}])
|
|
self.assert_(integer3)
|
|
self.assertEqual(integer3.integer, None)
|
|
|
|
integer4, = IntegerDefault.create([{}])
|
|
self.assert_(integer4)
|
|
self.assertEqual(integer4.integer, 5)
|
|
|
|
Integer.write([integer1], {
|
|
'integer': 0,
|
|
})
|
|
self.assertEqual(integer1.integer, 0)
|
|
|
|
Integer.write([integer2], {
|
|
'integer': 1,
|
|
})
|
|
self.assertEqual(integer2.integer, 1)
|
|
|
|
self.assertRaises(Exception, Integer.create, [{
|
|
'integer': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Integer.write, [integer1], {
|
|
'integer': 'test',
|
|
})
|
|
|
|
# We should catch UserError but mysql does not raise an
|
|
# IntegrityError but an OperationalError
|
|
self.assertRaises(Exception, IntegerRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
integer5, = IntegerRequired.create([{
|
|
'integer': 0,
|
|
}])
|
|
self.assert_(integer5)
|
|
self.assertEqual(integer5.integer, 0)
|
|
|
|
transaction.rollback()
|
|
|
|
@with_transaction()
|
|
def test_integer_with_domain(self):
|
|
'Test Integer with domain'
|
|
pool = Pool()
|
|
IntegerDomain = pool.get('test.integer_domain')
|
|
IntegerDomain.create([{
|
|
'integer': 100,
|
|
}])
|
|
self.assertRaises(UserError, IntegerDomain.create, [{
|
|
'integer': 10,
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_float(self):
|
|
'Test Float'
|
|
pool = Pool()
|
|
Float = pool.get('test.float')
|
|
FloatDefault = pool.get('test.float_default')
|
|
FloatRequired = pool.get('test.float_required')
|
|
FloatDigits = pool.get('test.float_digits')
|
|
transaction = Transaction()
|
|
|
|
float1, = Float.create([{
|
|
'float': 1.1,
|
|
}])
|
|
self.assert_(float1)
|
|
self.assertEqual(float1.float, 1.1)
|
|
|
|
floats = Float.search([
|
|
('float', '=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '=', 0),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '!=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '!=', 0),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', 'in', [1.1]),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', 'in', [0]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', 'in', []),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', 'not in', [1.1]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', 'not in', [0]),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', 'not in', []),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '<', 5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '<', -5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '<', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '<=', 5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '<=', -5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '<=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '>', 5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '>', -5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '>', 1.1),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '>=', 5),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
floats = Float.search([
|
|
('float', '>=', -5),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
floats = Float.search([
|
|
('float', '>=', 1.1),
|
|
])
|
|
self.assertEqual(floats, [float1])
|
|
|
|
float2, = Float.create([{
|
|
'float': 0,
|
|
}])
|
|
self.assert_(float2)
|
|
self.assertEqual(float2.float, 0)
|
|
|
|
floats = Float.search([
|
|
('float', '=', 0),
|
|
])
|
|
self.assertEqual(floats, [float2])
|
|
|
|
floats = Float.search([
|
|
('float', 'in', [0, 1.1]),
|
|
])
|
|
self.assertEqual(floats, [float1, float2])
|
|
|
|
floats = Float.search([
|
|
('float', 'not in', [0, 1.1]),
|
|
])
|
|
self.assertEqual(floats, [])
|
|
|
|
float3, = Float.create([{}])
|
|
self.assert_(float3)
|
|
self.assertEqual(float3.float, None)
|
|
|
|
float4, = FloatDefault.create([{}])
|
|
self.assert_(float4)
|
|
self.assertEqual(float4.float, 5.5)
|
|
|
|
Float.write([float1], {
|
|
'float': 0,
|
|
})
|
|
self.assertEqual(float1.float, 0)
|
|
|
|
Float.write([float2], {
|
|
'float': 1.1,
|
|
})
|
|
self.assertEqual(float2.float, 1.1)
|
|
|
|
self.assertRaises(Exception, Float.create, [{
|
|
'float': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Float.write, [float1], {
|
|
'float': 'test',
|
|
})
|
|
|
|
self.assertRaises(UserError, FloatRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
float5, = FloatRequired.create([{
|
|
'float': 0.0,
|
|
}])
|
|
self.assertEqual(float5.float, 0.0)
|
|
|
|
float6, = FloatDigits.create([{
|
|
'digits': 1,
|
|
'float': 1.1,
|
|
}])
|
|
self.assert_(float6)
|
|
|
|
self.assertRaises(UserError, FloatDigits.create, [{
|
|
'digits': 1,
|
|
'float': 1.11,
|
|
}])
|
|
|
|
self.assertRaises(UserError, FloatDigits.write,
|
|
[float6], {
|
|
'float': 1.11,
|
|
})
|
|
|
|
self.assertRaises(UserError, FloatDigits.write,
|
|
[float6], {
|
|
'digits': 0,
|
|
})
|
|
|
|
float7, = Float.create([{
|
|
'float': 0.123456789012345,
|
|
}])
|
|
self.assertEqual(float7.float, 0.123456789012345)
|
|
|
|
@with_transaction()
|
|
def test_float_search_none(self):
|
|
'Test float search with None'
|
|
pool = Pool()
|
|
Float = pool.get('test.float')
|
|
|
|
float_none, float0, float1 = Float.create([{
|
|
'float': None,
|
|
}, {
|
|
'float': 0,
|
|
}, {
|
|
'float': 1,
|
|
}])
|
|
self.assertEqual([float_none], Float.search([
|
|
('float', '=', None),
|
|
]))
|
|
self.assertEqual([float0], Float.search([
|
|
('float', '=', 0),
|
|
]))
|
|
self.assertEqual([float1], Float.search([
|
|
('float', '>', 0),
|
|
]))
|
|
|
|
self.assertEqual([float0, float1], Float.search([
|
|
('float', '!=', None),
|
|
]))
|
|
self.assertEqual([float1], Float.search([
|
|
('float', '!=', 0),
|
|
]))
|
|
self.assertEqual([float0], Float.search([
|
|
('float', '<', 1),
|
|
]))
|
|
|
|
self.assertEqual([float_none, float1], Float.search([
|
|
'OR',
|
|
('float', '>', 0),
|
|
('float', '=', None),
|
|
]))
|
|
|
|
@with_transaction()
|
|
def test_numeric(self):
|
|
'Test Numeric'
|
|
pool = Pool()
|
|
Numeric = pool.get('test.numeric')
|
|
NumericDefault = pool.get('test.numeric_default')
|
|
NumericRequired = pool.get('test.numeric_required')
|
|
NumericDigits = pool.get('test.numeric_digits')
|
|
transaction = Transaction()
|
|
|
|
numeric1, = Numeric.create([{
|
|
'numeric': Decimal('1.1'),
|
|
}])
|
|
self.assert_(numeric1)
|
|
self.assertEqual(numeric1.numeric, Decimal('1.1'))
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '!=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '!=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'in', [Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'in', [Decimal('0')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'in', []),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'not in', [Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'not in', [Decimal('0')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'not in', []),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<=', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<=', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '<=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>=', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>=', Decimal('-5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '>=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
numeric2, = Numeric.create([{
|
|
'numeric': Decimal('0'),
|
|
}])
|
|
self.assert_(numeric2)
|
|
self.assertEqual(numeric2.numeric, Decimal('0'))
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', '=', Decimal('0')),
|
|
])
|
|
self.assertEqual(numerics, [numeric2])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'in', [Decimal('0'), Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [numeric1, numeric2])
|
|
|
|
numerics = Numeric.search([
|
|
('numeric', 'not in', [Decimal('0'), Decimal('1.1')]),
|
|
])
|
|
self.assertEqual(numerics, [])
|
|
|
|
numeric3, = Numeric.create([{}])
|
|
self.assert_(numeric3)
|
|
self.assertEqual(numeric3.numeric, None)
|
|
|
|
numeric4, = NumericDefault.create([{}])
|
|
self.assert_(numeric4)
|
|
self.assertEqual(numeric4.numeric, Decimal('5.5'))
|
|
|
|
Numeric.write([numeric1], {
|
|
'numeric': Decimal('0'),
|
|
})
|
|
self.assertEqual(numeric1.numeric, Decimal('0'))
|
|
|
|
Numeric.write([numeric2], {
|
|
'numeric': Decimal('1.1'),
|
|
})
|
|
self.assertEqual(numeric2.numeric, Decimal('1.1'))
|
|
|
|
self.assertRaises(Exception, Numeric.create, [{
|
|
'numeric': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Numeric.write, [numeric1], {
|
|
'numeric': 'test',
|
|
})
|
|
|
|
self.assertRaises(UserError, NumericRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
numeric5, = NumericRequired.create([{
|
|
'numeric': Decimal(0),
|
|
}])
|
|
self.assertEqual(numeric5.numeric, 0)
|
|
|
|
numeric6, = NumericDigits.create([{
|
|
'digits': 1,
|
|
'numeric': Decimal('1.1'),
|
|
}])
|
|
self.assert_(numeric6)
|
|
|
|
self.assertRaises(UserError, NumericDigits.create, [{
|
|
'digits': 1,
|
|
'numeric': Decimal('1.11'),
|
|
}])
|
|
|
|
self.assertRaises(UserError, NumericDigits.write,
|
|
[numeric6], {
|
|
'numeric': Decimal('1.11'),
|
|
})
|
|
|
|
self.assertRaises(UserError, NumericDigits.write,
|
|
[numeric6], {
|
|
'numeric': Decimal('0.10000000000000001'),
|
|
})
|
|
|
|
self.assertRaises(UserError, NumericDigits.write,
|
|
[numeric6], {
|
|
'digits': 0,
|
|
})
|
|
|
|
numeric7, = Numeric.create([{
|
|
'numeric': Decimal('0.1234567890123456789'),
|
|
}])
|
|
self.assertEqual(numeric7.numeric,
|
|
Decimal('0.1234567890123456789'))
|
|
|
|
@with_transaction()
|
|
def test_numeric_search_cast(self):
|
|
'Test numeric search cast'
|
|
pool = Pool()
|
|
Numeric = pool.get('test.numeric')
|
|
|
|
numeric1, numeric2 = Numeric.create([{
|
|
'numeric': Decimal('1.1'),
|
|
}, {
|
|
'numeric': Decimal('100.0'),
|
|
}])
|
|
numerics = Numeric.search([
|
|
('numeric', '<', Decimal('5')),
|
|
])
|
|
self.assertEqual(numerics, [numeric1])
|
|
|
|
@with_transaction()
|
|
def test_numeric_search_none(self):
|
|
'Test numeric search with None'
|
|
pool = Pool()
|
|
Numeric = pool.get('test.numeric')
|
|
|
|
numeric_none, numeric0, numeric1 = Numeric.create([{
|
|
'numeric': None,
|
|
}, {
|
|
'numeric': 0,
|
|
}, {
|
|
'numeric': 1,
|
|
}])
|
|
self.assertEqual([numeric_none], Numeric.search([
|
|
('numeric', '=', None),
|
|
]))
|
|
self.assertEqual([numeric0], Numeric.search([
|
|
('numeric', '=', 0),
|
|
]))
|
|
self.assertEqual([numeric1], Numeric.search([
|
|
('numeric', '>', 0),
|
|
]))
|
|
|
|
self.assertEqual([numeric0, numeric1], Numeric.search([
|
|
('numeric', '!=', None),
|
|
]))
|
|
self.assertEqual([numeric1], Numeric.search([
|
|
('numeric', '!=', 0),
|
|
]))
|
|
self.assertEqual([numeric0], Numeric.search([
|
|
('numeric', '<', 1),
|
|
]))
|
|
|
|
self.assertEqual([numeric_none, numeric1], Numeric.search([
|
|
'OR',
|
|
('numeric', '>', 0),
|
|
('numeric', '=', None),
|
|
]))
|
|
|
|
@with_transaction()
|
|
def test_char(self):
|
|
'Test Char'
|
|
pool = Pool()
|
|
Char = pool.get('test.char')
|
|
CharDefault = pool.get('test.char_default')
|
|
CharRequired = pool.get('test.char_required')
|
|
CharSize = pool.get('test.char_size')
|
|
CharTranslate = pool.get('test.char_translate')
|
|
transaction = Transaction()
|
|
|
|
for char in (CharTranslate, 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, = Char.create([{}])
|
|
self.assert_(char3)
|
|
self.assertEqual(char3.char, None)
|
|
|
|
char4, = CharDefault.create([{}])
|
|
self.assert_(char4)
|
|
self.assertEqual(char4.char, 'Test')
|
|
|
|
Char.write([char1], {
|
|
'char': None,
|
|
})
|
|
self.assertEqual(char1.char, None)
|
|
|
|
Char.write([char2], {
|
|
'char': 'Test',
|
|
})
|
|
self.assertEqual(char2.char, 'Test')
|
|
|
|
self.assertRaises(UserError, CharRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, CharRequired.create, [{
|
|
'char': '',
|
|
}])
|
|
transaction.rollback()
|
|
|
|
char5, = CharRequired.create([{
|
|
'char': 'Test',
|
|
}])
|
|
self.assert_(char5)
|
|
|
|
char6, = CharSize.create([{
|
|
'char': 'Test',
|
|
}])
|
|
self.assert_(char6)
|
|
|
|
self.assertRaises(Exception, CharSize.create, [{
|
|
'char': 'foobar',
|
|
}])
|
|
|
|
self.assertRaises(Exception, CharSize.write, [char6], {
|
|
'char': 'foobar',
|
|
})
|
|
transaction.rollback()
|
|
|
|
char7, = Char.create([{
|
|
'char': u'é',
|
|
}])
|
|
self.assert_(char7)
|
|
self.assertEqual(char7.char, u'é')
|
|
|
|
chars = Char.search([
|
|
('char', '=', u'é'),
|
|
])
|
|
self.assertEqual(chars, [char7])
|
|
|
|
Char.write([char7], {
|
|
'char': 'é',
|
|
})
|
|
self.assertEqual(char7.char, u'é')
|
|
|
|
chars = Char.search([
|
|
('char', '=', 'é'),
|
|
])
|
|
self.assertEqual(chars, [char7])
|
|
|
|
@with_transaction()
|
|
def test_text(self):
|
|
'Test Text'
|
|
pool = Pool()
|
|
Text = pool.get('test.text')
|
|
TextDefault = pool.get('test.text_default')
|
|
TextRequired = pool.get('test.text_required')
|
|
TextSize = pool.get('test.text_size')
|
|
TextTranslate = pool.get('test.text_translate')
|
|
transaction = Transaction()
|
|
|
|
for text in (TextTranslate, 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, = Text.create([{}])
|
|
self.assert_(text3)
|
|
self.assertEqual(text3.text, None)
|
|
|
|
text4, = TextDefault.create([{}])
|
|
self.assert_(text4)
|
|
self.assertEqual(text4.text, 'Test')
|
|
|
|
Text.write([text1], {
|
|
'text': None,
|
|
})
|
|
self.assertEqual(text1.text, None)
|
|
|
|
Text.write([text2], {
|
|
'text': 'Test',
|
|
})
|
|
self.assertEqual(text2.text, 'Test')
|
|
|
|
self.assertRaises(UserError, TextRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
text5, = TextRequired.create([{
|
|
'text': 'Test',
|
|
}])
|
|
self.assert_(text5)
|
|
|
|
text6, = TextSize.create([{
|
|
'text': 'Test',
|
|
}])
|
|
self.assert_(text6)
|
|
|
|
self.assertRaises(UserError, TextSize.create, [{
|
|
'text': 'foobar',
|
|
}])
|
|
|
|
self.assertRaises(UserError, TextSize.write, [text6], {
|
|
'text': 'foobar',
|
|
})
|
|
|
|
text7, = Text.create([{
|
|
'text': 'Foo\nBar',
|
|
}])
|
|
self.assert_(text7)
|
|
|
|
text8, = Text.create([{
|
|
'text': u'é',
|
|
}])
|
|
self.assert_(text8)
|
|
self.assertEqual(text8.text, u'é')
|
|
|
|
texts = Text.search([
|
|
('text', '=', u'é'),
|
|
])
|
|
self.assertEqual(texts, [text8])
|
|
|
|
Text.write([text8], {
|
|
'text': 'é',
|
|
})
|
|
self.assertEqual(text8.text, u'é')
|
|
|
|
texts = Text.search([
|
|
('text', '=', 'é'),
|
|
])
|
|
self.assertEqual(texts, [text8])
|
|
|
|
@with_transaction()
|
|
def test_date(self):
|
|
'Test Date'
|
|
pool = Pool()
|
|
Date = pool.get('test.date')
|
|
DateDefault = pool.get('test.date_default')
|
|
DateRequired = pool.get('test.date_required')
|
|
transaction = 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, = Date.create([{
|
|
'date': today,
|
|
}])
|
|
self.assert_(date1)
|
|
self.assertEqual(date1.date, today)
|
|
|
|
dates = Date.search([
|
|
('date', '=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '=', None),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '!=', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '!=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '!=', None),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', 'in', [today]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', 'in', [tomorrow]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', 'in', [None]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', 'in', []),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', 'not in', [today]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', 'not in', [tomorrow]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', 'not in', [None]),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', 'not in', []),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '<', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '<', yesterday),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '<', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '<=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '<=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '<=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '>', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '>', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '>', today),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '>=', tomorrow),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
dates = Date.search([
|
|
('date', '>=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
dates = Date.search([
|
|
('date', '>=', today),
|
|
])
|
|
self.assertEqual(dates, [date1])
|
|
|
|
date2, = Date.create([{
|
|
'date': yesterday,
|
|
}])
|
|
self.assert_(date2)
|
|
self.assertEqual(date2.date, yesterday)
|
|
|
|
dates = Date.search([
|
|
('date', '=', yesterday),
|
|
])
|
|
self.assertEqual(dates, [date2])
|
|
|
|
dates = Date.search([
|
|
('date', 'in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(dates, [date1, date2])
|
|
|
|
dates = Date.search([
|
|
('date', 'not in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(dates, [])
|
|
|
|
date3, = Date.create([{}])
|
|
self.assert_(date3)
|
|
self.assertEqual(date3.date, None)
|
|
|
|
date4, = DateDefault.create([{}])
|
|
self.assert_(date4)
|
|
self.assertEqual(date4.date, default_date)
|
|
|
|
Date.write([date1], {
|
|
'date': yesterday,
|
|
})
|
|
self.assertEqual(date1.date, yesterday)
|
|
|
|
Date.write([date2], {
|
|
'date': today,
|
|
})
|
|
self.assertEqual(date2.date, today)
|
|
|
|
self.assertRaises(Exception, Date.create, [{
|
|
'date': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Date.write, [date1], {
|
|
'date': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, Date.create, [{
|
|
'date': 1,
|
|
}])
|
|
|
|
self.assertRaises(Exception, Date.write, [date1], {
|
|
'date': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, Date.create, [{
|
|
'date': datetime.datetime.now(),
|
|
}])
|
|
|
|
self.assertRaises(Exception, Date.write, [date1], {
|
|
'date': datetime.datetime.now(),
|
|
})
|
|
|
|
self.assertRaises(Exception, Date.create, [{
|
|
'date': '2009-13-01',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Date.write, [date1], {
|
|
'date': '2009-02-29',
|
|
})
|
|
|
|
date5, = Date.create([{
|
|
'date': '2009-01-01',
|
|
}])
|
|
self.assert_(date5)
|
|
self.assertEqual(date5.date, datetime.date(2009, 1, 1))
|
|
|
|
self.assertRaises(UserError, DateRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
date6, = DateRequired.create([{
|
|
'date': today,
|
|
}])
|
|
self.assert_(date6)
|
|
|
|
date7, = Date.create([{
|
|
'date': None,
|
|
}])
|
|
self.assert_(date7)
|
|
|
|
date8, = Date.create([{
|
|
'date': None,
|
|
}])
|
|
self.assert_(date8)
|
|
|
|
@with_transaction()
|
|
def test_datetime(self):
|
|
'Test DateTime'
|
|
pool = Pool()
|
|
Datetime = pool.get('test.datetime')
|
|
DatetimeDefault = pool.get('test.datetime_default')
|
|
DatetimeRequired = pool.get('test.datetime_required')
|
|
DatetimeFormat = pool.get('test.datetime_format')
|
|
transaction = 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, = Datetime.create([{
|
|
'datetime': today,
|
|
}])
|
|
self.assert_(datetime1)
|
|
self.assertEqual(datetime1.datetime, today)
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '=', None),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '!=', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '!=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '!=', None),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'in', [today]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'in', [tomorrow]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'in', [None]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'in', []),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'not in', [today]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'not in', [tomorrow]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'not in', [None]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'not in', []),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '<=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>', today),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>=', tomorrow),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '>=', today),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1])
|
|
|
|
datetime2, = Datetime.create([{
|
|
'datetime': yesterday,
|
|
}])
|
|
self.assert_(datetime2)
|
|
self.assertEqual(datetime2.datetime, yesterday)
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', '=', yesterday),
|
|
])
|
|
self.assertEqual(datetimes, [datetime2])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(datetimes, [datetime1, datetime2])
|
|
|
|
datetimes = Datetime.search([
|
|
('datetime', 'not in', [yesterday, today]),
|
|
])
|
|
self.assertEqual(datetimes, [])
|
|
|
|
datetime3, = Datetime.create([{}])
|
|
self.assert_(datetime3)
|
|
self.assertEqual(datetime3.datetime, None)
|
|
|
|
datetime4, = DatetimeDefault.create([{}])
|
|
self.assert_(datetime4)
|
|
self.assertEqual(datetime4.datetime, default_datetime)
|
|
|
|
Datetime.write([datetime1], {
|
|
'datetime': yesterday,
|
|
})
|
|
self.assertEqual(datetime1.datetime, yesterday)
|
|
|
|
Datetime.write([datetime2], {
|
|
'datetime': today,
|
|
})
|
|
self.assertEqual(datetime2.datetime, today)
|
|
|
|
self.assertRaises(Exception, Datetime.create, [{
|
|
'datetime': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Datetime.write, [datetime1],
|
|
{
|
|
'datetime': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, Datetime.create, [{
|
|
'datetime': 1,
|
|
}])
|
|
|
|
self.assertRaises(Exception, Datetime.write, [datetime1],
|
|
{
|
|
'datetime': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, Datetime.create, [{
|
|
'datetime': datetime.date.today(),
|
|
}])
|
|
|
|
self.assertRaises(Exception, Datetime.write, [datetime1],
|
|
{
|
|
'datetime': datetime.date.today(),
|
|
})
|
|
|
|
self.assertRaises(Exception, Datetime.create, [{
|
|
'datetime': '2009-13-01 12:30:00',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Datetime.write, [datetime1],
|
|
{
|
|
'datetime': '2009-02-29 12:30:00',
|
|
})
|
|
|
|
self.assertRaises(Exception, Datetime.write, [datetime1],
|
|
{
|
|
'datetime': '2009-01-01 25:00:00',
|
|
})
|
|
|
|
datetime5, = 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(UserError, DatetimeRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
datetime6, = DatetimeRequired.create([{
|
|
'datetime': today,
|
|
}])
|
|
self.assert_(datetime6)
|
|
|
|
datetime7, = Datetime.create([{
|
|
'datetime': None,
|
|
}])
|
|
self.assert_(datetime7)
|
|
|
|
datetime8, = Datetime.create([{
|
|
'datetime': None,
|
|
}])
|
|
self.assert_(datetime8)
|
|
|
|
datetime9, = Datetime.create([{
|
|
'datetime': today.replace(microsecond=1),
|
|
}])
|
|
self.assert_(datetime9)
|
|
self.assertEqual(datetime9.datetime, today)
|
|
|
|
# Test format
|
|
self.assert_(DatetimeFormat.create([{
|
|
'datetime': datetime.datetime(2009, 1, 1, 12, 30),
|
|
}]))
|
|
self.assertRaises(UserError, DatetimeFormat.create, [{
|
|
'datetime': datetime.datetime(2009, 1, 1, 12, 30, 25),
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_time(self):
|
|
'Test Time'
|
|
pool = Pool()
|
|
Time = pool.get('test.time')
|
|
TimeDefault = pool.get('test.time_default')
|
|
TimeRequired = pool.get('test.time_required')
|
|
TimeFormat = pool.get('test.time_format')
|
|
transaction = 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, = Time.create([{
|
|
'time': evening,
|
|
}])
|
|
self.assert_(time1)
|
|
self.assertEqual(time1.time, evening)
|
|
|
|
times = Time.search([
|
|
('time', '=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '=', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '=', None),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '!=', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '!=', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '!=', None),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', 'in', [evening]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', 'in', [night]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', 'in', [None]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', 'in', []),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', 'not in', [evening]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', 'not in', [night]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', 'not in', [None]),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', 'not in', []),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '<', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '<', pre_evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '<', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '<=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '<=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '<=', night),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '>', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '>', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '>', evening),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '>=', night),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
times = Time.search([
|
|
('time', '>=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
times = Time.search([
|
|
('time', '>=', evening),
|
|
])
|
|
self.assertEqual(times, [time1])
|
|
|
|
time2, = Time.create([{
|
|
'time': pre_evening,
|
|
}])
|
|
self.assert_(time2)
|
|
self.assertEqual(time2.time, pre_evening)
|
|
|
|
times = Time.search([
|
|
('time', '=', pre_evening),
|
|
])
|
|
self.assertEqual(times, [time2])
|
|
|
|
times = Time.search([
|
|
('time', 'in', [pre_evening, evening]),
|
|
])
|
|
self.assertEqual(times, [time1, time2])
|
|
|
|
times = Time.search([
|
|
('time', 'not in', [pre_evening, evening]),
|
|
])
|
|
self.assertEqual(times, [])
|
|
|
|
time3, = Time.create([{}])
|
|
self.assert_(time3)
|
|
self.assertEqual(time3.time, None)
|
|
|
|
time4, = TimeDefault.create([{}])
|
|
self.assert_(time4)
|
|
self.assertEqual(time4.time, default_time)
|
|
|
|
Time.write([time1], {
|
|
'time': pre_evening,
|
|
})
|
|
self.assertEqual(time1.time, pre_evening)
|
|
|
|
Time.write([time2], {
|
|
'time': evening,
|
|
})
|
|
self.assertEqual(time2.time, evening)
|
|
|
|
self.assertRaises(Exception, Time.create, [{
|
|
'time': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Time.write, [time1],
|
|
{
|
|
'time': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, Time.create, [{
|
|
'time': 1,
|
|
}])
|
|
|
|
self.assertRaises(Exception, Time.write, [time1],
|
|
{
|
|
'time': 1,
|
|
})
|
|
|
|
self.assertRaises(Exception, Time.write, [time1],
|
|
{
|
|
'time': '25:00:00',
|
|
})
|
|
|
|
time5, = Time.create([{
|
|
'time': '12:00:00',
|
|
}])
|
|
self.assert_(time5)
|
|
self.assertEqual(time5.time, datetime.time(12, 0))
|
|
|
|
self.assertRaises(UserError, TimeRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
time6, = TimeRequired.create([{
|
|
'time': evening,
|
|
}])
|
|
self.assert_(time6)
|
|
|
|
time7, = Time.create([{
|
|
'time': None,
|
|
}])
|
|
self.assert_(time7)
|
|
|
|
time9, = Time.create([{
|
|
'time': evening.replace(microsecond=1),
|
|
}])
|
|
self.assert_(time9)
|
|
self.assertEqual(time9.time, evening)
|
|
|
|
# Test format
|
|
self.assert_(TimeFormat.create([{
|
|
'time': datetime.time(12, 30),
|
|
}]))
|
|
self.assertRaises(UserError, TimeFormat.create, [{
|
|
'time': datetime.time(12, 30, 25),
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_one2one(self):
|
|
'Test One2One'
|
|
pool = Pool()
|
|
One2one = pool.get('test.one2one')
|
|
One2oneTarget = pool.get('test.one2one.target')
|
|
One2oneRequired = pool.get('test.one2one_required')
|
|
One2oneDomain = pool.get('test.one2one_domain')
|
|
transaction = Transaction()
|
|
|
|
target1, = One2oneTarget.create([{
|
|
'name': 'target1',
|
|
}])
|
|
one2one1, = One2one.create([{
|
|
'name': 'origin1',
|
|
'one2one': target1.id,
|
|
}])
|
|
self.assert_(one2one1)
|
|
self.assertEqual(one2one1.one2one, target1)
|
|
|
|
self.assertEqual(One2one.read([one2one1.id],
|
|
['one2one.name'])[0]['one2one.name'], 'target1')
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', 'in', [target1.id]),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', 'in', [0]),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', 'not in', [target1.id]),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', 'not in', [0]),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one.name', '=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [one2one1])
|
|
|
|
one2ones = One2one.search([
|
|
('one2one.name', '!=', 'target1'),
|
|
])
|
|
self.assertEqual(one2ones, [])
|
|
|
|
one2one2, = One2one.create([{
|
|
'name': 'origin2',
|
|
}])
|
|
self.assert_(one2one2)
|
|
self.assertEqual(one2one2.one2one, None)
|
|
|
|
one2ones = One2one.search([
|
|
('one2one', '=', None),
|
|
])
|
|
self.assertEqual(one2ones, [one2one2])
|
|
|
|
target2, = One2oneTarget.create([{
|
|
'name': 'target2',
|
|
}])
|
|
One2one.write([one2one2], {
|
|
'one2one': target2.id,
|
|
})
|
|
self.assertEqual(one2one2.one2one, target2)
|
|
|
|
One2one.write([one2one2], {
|
|
'one2one': None,
|
|
})
|
|
self.assertEqual(one2one2.one2one, None)
|
|
|
|
self.assertRaises(UserError, One2one.create, [{
|
|
'name': 'one2one3',
|
|
'one2one': target1.id,
|
|
}])
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, One2one.write, [one2one2], {
|
|
'one2one': target1.id,
|
|
})
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, One2oneRequired.create, [{
|
|
'name': 'one2one3',
|
|
}])
|
|
transaction.rollback()
|
|
|
|
target3, = One2oneTarget.create([{
|
|
'name': 'target3',
|
|
}])
|
|
|
|
one2one3, = One2oneRequired.create([{
|
|
'name': 'one2one3',
|
|
'one2one': target3.id,
|
|
}])
|
|
self.assert_(one2one3)
|
|
|
|
target4, = One2oneTarget.create([{
|
|
'name': 'target4',
|
|
}])
|
|
self.assertRaises(UserError, One2oneDomain.create, [{
|
|
'name': 'one2one4',
|
|
'one2one': target4.id,
|
|
}])
|
|
transaction.rollback()
|
|
|
|
target5, = One2oneTarget.create([{
|
|
'name': 'domain',
|
|
}])
|
|
one2one5, = One2oneDomain.create([{
|
|
'name': 'one2one5',
|
|
'one2one': target5.id,
|
|
}])
|
|
targets = One2oneTarget.create([{
|
|
'name': 'multiple1',
|
|
}, {
|
|
'name': 'multiple2',
|
|
}])
|
|
one2ones = One2one.create([{
|
|
'name': 'origin6',
|
|
'one2one': targets[0].id,
|
|
}, {
|
|
'name': 'origin7',
|
|
'one2one': targets[1].id,
|
|
}])
|
|
for one2one, target in zip(one2ones, targets):
|
|
self.assert_(one2one)
|
|
self.assertEqual(one2one.one2one, target)
|
|
|
|
@with_transaction()
|
|
def test_one2many(self):
|
|
'Test One2Many'
|
|
pool = Pool()
|
|
One2many = pool.get('test.one2many')
|
|
One2manyTarget = pool.get('test.one2many.target')
|
|
One2manyRequired = pool.get('test.one2many_required')
|
|
One2manyReference = pool.get('test.one2many_reference')
|
|
One2manyReferenceTarget = pool.get('test.one2many_reference.target')
|
|
One2manySize = pool.get('test.one2many_size')
|
|
One2manySizePyson = pool.get('test.one2many_size_pyson')
|
|
transaction = Transaction()
|
|
|
|
for one2many, one2many_target in (
|
|
(One2many, One2manyTarget),
|
|
(One2manyReference, One2manyReferenceTarget),
|
|
):
|
|
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, [])
|
|
|
|
one2manys = one2many.search([
|
|
('targets', 'where', [('name', '=', 'target1')]),
|
|
])
|
|
self.assertEqual(one2manys, [one2many1])
|
|
one2manys = one2many.search([
|
|
('targets', 'not where', [('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': [
|
|
('remove', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, (target1,))
|
|
target2, = one2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assert_(target2)
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('remove', [target1.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, ())
|
|
targets = one2many_target.search([
|
|
('id', 'in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(targets, [target1, target2])
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('add', [target1.id, target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets,
|
|
(target1, target2))
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('copy', [target1.id], {'name': 'copy1'}),
|
|
],
|
|
})
|
|
targets = one2many_target.search([
|
|
('id', 'not in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(len(targets), 1)
|
|
self.assertEqual(targets[0].name, 'copy1')
|
|
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('copy', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(len(one2many1.targets), 4)
|
|
targets = one2many_target.search([
|
|
('id', 'not in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(len(targets), 2)
|
|
names = set([target.name for target in targets])
|
|
self.assertEqual(names, set(('copy1', 'target2')))
|
|
|
|
copy_ids = [target.id for target in targets]
|
|
one2many.write([one2many1], {
|
|
'targets': [
|
|
('delete', [target2.id] + copy_ids),
|
|
],
|
|
})
|
|
self.assertEqual(one2many1.targets, (target1,))
|
|
targets = one2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, One2manyRequired.create, [{
|
|
'name': 'origin3',
|
|
}])
|
|
transaction.rollback()
|
|
|
|
origin3_id, = One2manyRequired.create([{
|
|
'name': 'origin3',
|
|
'targets': [
|
|
('create', [{
|
|
'name': 'target3',
|
|
}]),
|
|
],
|
|
}])
|
|
self.assert_(origin3_id)
|
|
|
|
One2manySize.create([{
|
|
'targets': [('create', [{}])] * 3,
|
|
}])
|
|
self.assertRaises(UserError, One2manySize.create, [{
|
|
'targets': [('create', [{}])] * 4,
|
|
}])
|
|
One2manySizePyson.create([{
|
|
'limit': 4,
|
|
'targets': [('create', [{}])] * 4,
|
|
}])
|
|
self.assertRaises(UserError, One2manySizePyson.create, [{
|
|
'limit': 2,
|
|
'targets': [('create', [{}])] * 4,
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_many2many(self):
|
|
'Test Many2Many'
|
|
pool = Pool()
|
|
Many2many = pool.get('test.many2many')
|
|
Many2manyTarget = pool.get('test.many2many.target')
|
|
Many2manyRequired = pool.get('test.many2many_required')
|
|
Many2manyReference = pool.get('test.many2many_reference')
|
|
Many2manyReferenceTarget = pool.get('test.many2many_reference.target')
|
|
Many2manySizeTarget = pool.get('test.many2many_size.target')
|
|
transaction = Transaction()
|
|
|
|
for many2many, many2many_target in (
|
|
(Many2many, Many2manyTarget),
|
|
(Many2manyReference, Many2manyReferenceTarget),
|
|
):
|
|
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, [])
|
|
|
|
many2manys = many2many.search([
|
|
('targets', 'where', [('name', '=', 'target1')]),
|
|
])
|
|
self.assertEqual(many2manys, [many2many1])
|
|
many2manys = many2many.search([
|
|
('targets', 'not where', [('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': [
|
|
('remove', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, (target1,))
|
|
target2, = many2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assert_(target2)
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('remove', [target1.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, ())
|
|
targets = many2many_target.search([
|
|
('id', 'in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(targets, [target1, target2])
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('add', [target1.id, target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets,
|
|
(target1, target2))
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('copy', [target1.id], {'name': 'copy1'}),
|
|
],
|
|
})
|
|
targets = many2many_target.search([
|
|
('id', 'not in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(len(targets), 1)
|
|
self.assertEqual(targets[0].name, 'copy1')
|
|
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('copy', [target2.id]),
|
|
],
|
|
})
|
|
self.assertEqual(len(many2many1.targets), 4)
|
|
targets = many2many_target.search([
|
|
('id', 'not in', [target1.id, target2.id]),
|
|
])
|
|
self.assertEqual(len(targets), 2)
|
|
names = set([target.name for target in targets])
|
|
self.assertEqual(names, set(('copy1', 'target2')))
|
|
|
|
copy_ids = [target.id for target in targets]
|
|
many2many.write([many2many1], {
|
|
'targets': [
|
|
('delete', [target2.id] + copy_ids),
|
|
],
|
|
})
|
|
self.assertEqual(many2many1.targets, (target1,))
|
|
targets = many2many_target.search([
|
|
('id', '=', target2.id),
|
|
])
|
|
self.assertEqual(targets, [])
|
|
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, Many2manyRequired.create, [{
|
|
'name': 'origin3',
|
|
}])
|
|
transaction.rollback()
|
|
|
|
origin3_id, = Many2manyRequired.create([{
|
|
'name': 'origin3',
|
|
'targets': [
|
|
('create', [{
|
|
'name': 'target3',
|
|
}]),
|
|
],
|
|
}])
|
|
self.assert_(origin3_id)
|
|
|
|
Many2manySizeTarget.create([{
|
|
'name': str(i),
|
|
} for i in range(6)])
|
|
|
|
transaction.rollback()
|
|
|
|
@with_transaction()
|
|
def test_many2many_tree(self):
|
|
pool = Pool()
|
|
Many2Many = pool.get('test.many2many_tree')
|
|
|
|
second1, second2, second3, second4 = Many2Many.create([
|
|
{},
|
|
{},
|
|
{},
|
|
{},
|
|
])
|
|
first1, first2, first3, first4 = Many2Many.create([
|
|
{'children': [('add', [second1.id, second2.id])]},
|
|
{'children': [('add', [second1.id, second2.id])]},
|
|
{'children': [('add', [second3.id, second4.id])]},
|
|
{'children': [('add', [second4.id])]},
|
|
])
|
|
root1, root2 = Many2Many.create([
|
|
{'children': [
|
|
('add', [first1.id, first2.id, second1.id])]},
|
|
{'children': [('add', [first3.id, first4.id])]},
|
|
])
|
|
|
|
all_ = Many2Many.search([])
|
|
|
|
def not_(l):
|
|
return [r for r in all_ if r not in l]
|
|
|
|
for clause, test in [
|
|
([root1.id], [second1, second2, first1, first2, root1]),
|
|
([second1.id], [second1]),
|
|
([root2.id], [second3, second4, first3, first4, root2]),
|
|
([], []),
|
|
]:
|
|
result = Many2Many.search(
|
|
[('parents', 'child_of', clause)])
|
|
self.assertEqual(result, test)
|
|
|
|
result = Many2Many.search(
|
|
[('parents', 'not child_of', clause)])
|
|
self.assertEqual(result, not_(test))
|
|
|
|
for clause, test in [
|
|
([root1.id], [root1]),
|
|
([first3.id], [first3, root2]),
|
|
([second4.id], [second4, first3, first4, root2]),
|
|
([second4.id, first4.id], [second4, first3, first4,
|
|
root2]),
|
|
([], []),
|
|
]:
|
|
result = Many2Many.search(
|
|
[('parents', 'parent_of', clause)])
|
|
self.assertEqual(result, test)
|
|
|
|
result = Many2Many.search(
|
|
[('parents', 'not parent_of', clause)])
|
|
self.assertEqual(result, not_(test))
|
|
|
|
@with_transaction()
|
|
def test_reference(self):
|
|
'Test Reference'
|
|
pool = Pool()
|
|
Reference = pool.get('test.reference')
|
|
ReferenceTarget = pool.get('test.reference.target')
|
|
ReferenceRequired = pool.get('test.reference_required')
|
|
transaction = Transaction()
|
|
|
|
target1, = ReferenceTarget.create([{
|
|
'name': 'target1',
|
|
}])
|
|
reference1, = Reference.create([{
|
|
'name': 'reference1',
|
|
'reference': str(target1),
|
|
}])
|
|
self.assert_(reference1)
|
|
|
|
self.assertEqual(reference1.reference, target1)
|
|
|
|
references = Reference.search([
|
|
('reference', '=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference', '=', (target1.__name__, target1.id)),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference', '=', [target1.__name__, target1.id]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference.name', '=', 'target1',
|
|
'test.reference.target'),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference', '!=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = Reference.search([
|
|
('reference', '!=', str(target1)),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = Reference.search([
|
|
('reference', 'in', [str(target1)]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference', 'in',
|
|
[('test.reference.target', target1.id)]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
references = Reference.search([
|
|
('reference', 'in', [None]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = Reference.search([
|
|
('reference', 'not in', [str(target1)]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = Reference.search([
|
|
('reference', 'not in',
|
|
[('test.reference.target', target1.id)]),
|
|
])
|
|
self.assertEqual(references, [])
|
|
|
|
references = Reference.search([
|
|
('reference', 'not in', [None]),
|
|
])
|
|
self.assertEqual(references, [reference1])
|
|
|
|
reference2, = Reference.create([{
|
|
'name': 'reference2',
|
|
}])
|
|
self.assert_(reference2)
|
|
|
|
self.assertEqual(reference2.reference, None)
|
|
|
|
references = Reference.search([
|
|
('reference', '=', None),
|
|
])
|
|
self.assertEqual(references, [reference2])
|
|
|
|
target2, = ReferenceTarget.create([{
|
|
'name': 'target2',
|
|
}])
|
|
|
|
Reference.write([reference2], {
|
|
'reference': str(target2),
|
|
})
|
|
self.assertEqual(reference2.reference, target2)
|
|
|
|
Reference.write([reference2], {
|
|
'reference': None,
|
|
})
|
|
self.assertEqual(reference2.reference, None)
|
|
|
|
Reference.write([reference2], {
|
|
'reference': ('test.reference.target', target2.id),
|
|
})
|
|
self.assertEqual(reference2.reference, target2)
|
|
|
|
reference3, = Reference.create([{
|
|
'name': 'reference3',
|
|
'reference': ('test.reference.target', target1.id),
|
|
}])
|
|
self.assert_(reference3)
|
|
|
|
self.assertRaises(UserError, ReferenceRequired.create, [{
|
|
'name': 'reference4',
|
|
}])
|
|
transaction.rollback()
|
|
|
|
target4, = ReferenceTarget.create([{
|
|
'name': 'target4_id',
|
|
}])
|
|
|
|
reference4, = ReferenceRequired.create([{
|
|
'name': 'reference4',
|
|
'reference': str(target4),
|
|
}])
|
|
self.assert_(reference4)
|
|
|
|
@with_transaction()
|
|
def test_property(self):
|
|
'Test Property with supported field types'
|
|
pool = Pool()
|
|
Property = pool.get('test.property')
|
|
IrProperty = pool.get('ir.property')
|
|
ModelField = pool.get('ir.model.field')
|
|
Char = pool.get('test.char')
|
|
transaction = Transaction()
|
|
|
|
# Test Char
|
|
prop_a, = Property.create([{'char': 'Test'}])
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.char, 'Test')
|
|
|
|
prop_b, = Property.create([{}])
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.char, None)
|
|
|
|
prop_c, = Property.create([{'char': 'FooBar'}])
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.char, 'FooBar')
|
|
|
|
props = Property.search([('char', '=', 'Test')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([('char', '=', None)])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
props = Property.search([('char', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_c])
|
|
|
|
props = Property.search([('char', 'like', 'Tes%')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([('char', 'like', '%Bar')])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = Property.search([('char', 'not like', 'Tes%')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = Property.search([('char', 'ilike', 'tes%')])
|
|
self.assert_(props, [prop_a])
|
|
|
|
props = Property.search([('char', 'ilike', '%bar')])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = Property.search([('char', 'not ilike', 'tes%')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = Property.search([('char', 'in', ['Test'])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([
|
|
('char', 'in', ['Test', 'FooBar'])])
|
|
self.assertEqual(props, [prop_a, prop_c])
|
|
|
|
props = Property.search([
|
|
('char', 'not in', ['Test', 'FooBar'])])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
# Test default value
|
|
property_field, = ModelField.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'char'),
|
|
], limit=1)
|
|
IrProperty.create([{
|
|
'field': property_field.id,
|
|
'value': ',DEFAULT_VALUE',
|
|
}])
|
|
|
|
prop_d, = Property.create([{}])
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.char, 'DEFAULT_VALUE')
|
|
|
|
props = Property.search([('char', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_c, prop_d])
|
|
|
|
Property.write([prop_a], {'char': None})
|
|
self.assertEqual(prop_a.char, None)
|
|
|
|
Property.write([prop_b], {'char': 'Test'})
|
|
self.assertEqual(prop_b.char, 'Test')
|
|
|
|
transaction.rollback()
|
|
|
|
# Test Many2One
|
|
char_a, = Char.create([{'char': 'Test'}])
|
|
self.assert_(char_a)
|
|
|
|
char_b, = Char.create([{'char': 'FooBar'}])
|
|
self.assert_(char_b)
|
|
|
|
prop_a, = Property.create([{'many2one': char_a.id}])
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.many2one, char_a)
|
|
|
|
prop_b, = Property.create([{'many2one': char_b.id}])
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.many2one, char_b)
|
|
|
|
prop_c, = Property.create([{}])
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.many2one, None)
|
|
|
|
props = Property.search([('many2one', '=', char_a.id)])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([('many2one', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([('many2one', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
self.assertEqual(prop_a.many2one, char_a)
|
|
|
|
props = Property.search([
|
|
('many2one', 'in', [char_a.id, char_b.id])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([
|
|
('many2one', 'not in', [char_a.id, char_b.id])])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
Property.write([prop_b], {'many2one': char_a.id})
|
|
self.assertEqual(prop_b.many2one, char_a)
|
|
|
|
transaction.rollback()
|
|
|
|
# Test Numeric
|
|
prop_a, = Property.create([{'numeric': Decimal('1.1')}])
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.numeric, Decimal('1.1'))
|
|
|
|
prop_b, = Property.create([{'numeric': Decimal('2.6')}])
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.numeric, Decimal('2.6'))
|
|
|
|
prop_c, = Property.create([{}])
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.numeric, None)
|
|
|
|
props = Property.search([('numeric', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([('numeric', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = Property.search([
|
|
('numeric', '=', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([
|
|
('numeric', '!=', Decimal('1.1'))])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = Property.search([
|
|
('numeric', '<', Decimal('2.6')),
|
|
])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([
|
|
('numeric', '<=', Decimal('2.6'))])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([
|
|
('numeric', '>', Decimal('1.1')),
|
|
])
|
|
self.assertEqual(props, [prop_b])
|
|
|
|
props = Property.search([
|
|
('numeric', '>=', Decimal('1.1'))])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([
|
|
('numeric', 'in', [Decimal('1.1')])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([
|
|
('numeric', 'in', [Decimal('1.1'), Decimal('2.6')])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([
|
|
('numeric', 'not in', [Decimal('1.1')])])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = Property.search([
|
|
('numeric', 'not in', [Decimal('1.1'), Decimal('2.6')])])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
# Test default value
|
|
property_field, = ModelField.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'numeric'),
|
|
], limit=1)
|
|
IrProperty.create([{
|
|
'field': property_field.id,
|
|
'value': ',3.7',
|
|
}])
|
|
|
|
prop_d, = Property.create([{}])
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.numeric, Decimal('3.7'))
|
|
|
|
Property.write([prop_a], {'numeric': None})
|
|
self.assertEqual(prop_a.numeric, None)
|
|
|
|
Property.write([prop_b], {'numeric': Decimal('3.11')})
|
|
self.assertEqual(prop_b.numeric, Decimal('3.11'))
|
|
|
|
transaction.rollback()
|
|
|
|
# Test Selection
|
|
prop_a, = Property.create([{'selection': 'option_a'}])
|
|
self.assert_(prop_a)
|
|
self.assertEqual(prop_a.selection, 'option_a')
|
|
|
|
prop_b, = Property.create([{'selection': 'option_b'}])
|
|
self.assert_(prop_b)
|
|
self.assertEqual(prop_b.selection, 'option_b')
|
|
|
|
prop_c, = Property.create([{}])
|
|
self.assert_(prop_c)
|
|
self.assertEqual(prop_c.selection, None)
|
|
|
|
props = Property.search([('selection', '=', 'option_a')])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([('selection', '!=', None)])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([('selection', '=', None)])
|
|
self.assertEqual(props, [prop_c])
|
|
|
|
props = Property.search([('selection', '!=', 'option_a')])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
props = Property.search([
|
|
('selection', 'in', ['option_a'])])
|
|
self.assertEqual(props, [prop_a])
|
|
|
|
props = Property.search([
|
|
('selection', 'in', ['option_a', 'option_b'])])
|
|
self.assertEqual(props, [prop_a, prop_b])
|
|
|
|
props = Property.search([
|
|
('selection', 'not in', ['option_a'])])
|
|
self.assertEqual(props, [prop_b, prop_c])
|
|
|
|
# Test default value
|
|
property_field, = ModelField.search([
|
|
('model.model', '=', 'test.property'),
|
|
('name', '=', 'selection'),
|
|
], limit=1)
|
|
IrProperty.create([{
|
|
'field': property_field.id,
|
|
'value': ',option_a',
|
|
}])
|
|
|
|
prop_d, = Property.create([{}])
|
|
self.assert_(prop_d)
|
|
self.assertEqual(prop_d.selection, 'option_a')
|
|
|
|
Property.write([prop_a], {'selection': None})
|
|
self.assertEqual(prop_a.selection, None)
|
|
|
|
Property.write([prop_c], {'selection': 'option_b'})
|
|
self.assertEqual(prop_c.selection, 'option_b')
|
|
|
|
@with_transaction()
|
|
def test_selection(self):
|
|
'Test Selection'
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection')
|
|
SelectionRequired = pool.get('test.selection_required')
|
|
transaction = Transaction()
|
|
|
|
selection1, = Selection.create([{'select': 'arabic'}])
|
|
self.assert_(selection1)
|
|
self.assertEqual(selection1.select, 'arabic')
|
|
self.assertEqual(selection1.select_string, 'Arabic')
|
|
|
|
selection2, = Selection.create([{'select': None}])
|
|
self.assert_(selection2)
|
|
self.assertEqual(selection2.select, None)
|
|
self.assertEqual(selection2.select_string, '')
|
|
|
|
self.assertRaises(UserError, Selection.create,
|
|
[{'select': 'chinese'}])
|
|
|
|
selection3, = Selection.create(
|
|
[{'select': 'arabic', 'dyn_select': '1'}])
|
|
self.assert_(selection3)
|
|
self.assertEqual(selection3.select, 'arabic')
|
|
self.assertEqual(selection3.dyn_select, '1')
|
|
|
|
selection4, = Selection.create(
|
|
[{'select': 'hexa', 'dyn_select': '0x3'}])
|
|
self.assert_(selection4)
|
|
self.assertEqual(selection4.select, 'hexa')
|
|
self.assertEqual(selection4.dyn_select, '0x3')
|
|
|
|
selection5, = Selection.create(
|
|
[{'select': 'hexa', 'dyn_select': None}])
|
|
self.assert_(selection5)
|
|
self.assertEqual(selection5.select, 'hexa')
|
|
self.assertEqual(selection5.dyn_select, None)
|
|
|
|
self.assertRaises(UserError, Selection.create,
|
|
[{'select': 'arabic', 'dyn_select': '0x3'}])
|
|
self.assertRaises(UserError, Selection.create,
|
|
[{'select': 'hexa', 'dyn_select': '3'}])
|
|
|
|
self.assertRaises(UserError, SelectionRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
self.assertRaises(UserError, SelectionRequired.create,
|
|
[{'select': None}])
|
|
transaction.rollback()
|
|
|
|
selection6, = SelectionRequired.create([{'select': 'latin'}])
|
|
self.assert_(selection6)
|
|
self.assertEqual(selection6.select, 'latin')
|
|
|
|
@with_transaction()
|
|
def test_dict(self):
|
|
'Test Dict'
|
|
pool = Pool()
|
|
Dict = pool.get('test.dict')
|
|
DictSchema = pool.get('test.dict.schema')
|
|
DictDefault = pool.get('test.dict_default')
|
|
DictRequired = pool.get('test.dict_required')
|
|
transaction = Transaction()
|
|
|
|
DictSchema.create([{
|
|
'name': 'a',
|
|
'string': 'A',
|
|
'type_': 'integer',
|
|
}, {
|
|
'name': 'b',
|
|
'string': 'B',
|
|
'type_': 'integer',
|
|
}, {
|
|
'name': 'type',
|
|
'string': 'Type',
|
|
'type_': 'selection',
|
|
'selection': ('arabic: Arabic\n'
|
|
'hexa: Hexadecimal'),
|
|
}])
|
|
|
|
dict1, = Dict.create([{
|
|
'dico': {'a': 1, 'b': 2},
|
|
}])
|
|
self.assert_(dict1.dico == {'a': 1, 'b': 2})
|
|
|
|
Dict.write([dict1], {'dico': {'z': 26}})
|
|
self.assert_(dict1.dico == {'z': 26})
|
|
|
|
dict1.dico = {
|
|
'a': 1,
|
|
'type': 'arabic',
|
|
}
|
|
dict1.save()
|
|
self.assertEqual(dict1.dico, {'a': 1, 'type': 'arabic'})
|
|
self.assertEqual(dict1.dico_string, {
|
|
'a': 1,
|
|
'type': 'Arabic',
|
|
})
|
|
self.assertEqual(dict1.dico_string_keys, {
|
|
'a': 'A',
|
|
'type': 'Type',
|
|
})
|
|
|
|
dict2, = Dict.create([{}])
|
|
self.assert_(dict2.dico is None)
|
|
|
|
dict3, = DictDefault.create([{}])
|
|
self.assert_(dict3.dico == {'a': 1})
|
|
|
|
self.assertRaises(UserError, DictRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
dict4, = DictRequired.create([{'dico': dict(a=1)}])
|
|
self.assert_(dict4.dico == {'a': 1})
|
|
|
|
self.assertRaises(UserError, DictRequired.create,
|
|
[{'dico': {}}])
|
|
|
|
@with_transaction()
|
|
def test_binary(self):
|
|
'Test Binary'
|
|
pool = Pool()
|
|
Binary = pool.get('test.binary')
|
|
BinaryDefault = pool.get('test.binary_default')
|
|
BinaryRequired = pool.get('test.binary_required')
|
|
transaction = Transaction()
|
|
|
|
bin1, = Binary.create([{
|
|
'binary': fields.Binary.cast(b'foo'),
|
|
}])
|
|
self.assert_(bin1.binary == fields.Binary.cast(b'foo'))
|
|
|
|
Binary.write([bin1], {'binary': fields.Binary.cast(b'bar')})
|
|
self.assert_(bin1.binary == fields.Binary.cast(b'bar'))
|
|
|
|
with transaction.set_context({'test.binary.binary': 'size'}):
|
|
bin1_size = Binary(bin1.id)
|
|
self.assert_(bin1_size.binary == len(b'bar'))
|
|
self.assert_(bin1_size.binary != fields.Binary.cast(b'bar'))
|
|
|
|
bin2, = Binary.create([{}])
|
|
self.assert_(bin2.binary is None)
|
|
|
|
bin3, = BinaryDefault.create([{}])
|
|
self.assert_(bin3.binary == fields.Binary.cast(b'default'))
|
|
|
|
self.assertRaises(UserError, BinaryRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
bin4, = BinaryRequired.create([{
|
|
'binary': fields.Binary.cast(b'baz'),
|
|
}])
|
|
self.assert_(bin4.binary == fields.Binary.cast(b'baz'))
|
|
|
|
self.assertRaises(UserError, BinaryRequired.create,
|
|
[{'binary': fields.Binary.cast(b'')}])
|
|
|
|
@with_transaction()
|
|
def test_many2one(self):
|
|
'Test Many2One'
|
|
pool = Pool()
|
|
Many2oneDomainValidation = pool.get('test.many2one_domainvalidation')
|
|
Many2oneOrderby = pool.get('test.many2one_orderby')
|
|
Many2oneTarget = pool.get('test.many2one_target')
|
|
Many2oneSearch = pool.get('test.many2one_search')
|
|
transaction = Transaction()
|
|
|
|
# Not respecting the domain raise an Error
|
|
m2o_1, = Many2oneTarget.create([{'value': 1}])
|
|
self.assertRaises(UserError, Many2oneDomainValidation.create,
|
|
[{'many2one': m2o_1}])
|
|
|
|
# Respecting the domain works
|
|
m2o_6, = Many2oneTarget.create([{'value': 6}])
|
|
domain, = Many2oneDomainValidation.create([{'many2one': m2o_6}])
|
|
self.assert_(domain)
|
|
self.assertEqual(domain.many2one.value, 6)
|
|
|
|
# Inactive records are taken into account
|
|
m2o_6.active = False
|
|
m2o_6.save()
|
|
domain.dummy = 'Dummy'
|
|
domain.save()
|
|
|
|
# Testing order_by
|
|
for value in (5, 3, 2):
|
|
m2o, = Many2oneTarget.create([{'value': value}])
|
|
Many2oneOrderby.create([{'many2one': m2o}])
|
|
|
|
search = Many2oneOrderby.search([], order=[('many2one', 'ASC')])
|
|
self.assertTrue(all(x.many2one.value <= y.many2one.value
|
|
for x, y in zip(search, search[1:])))
|
|
|
|
search = Many2oneOrderby.search([],
|
|
order=[('many2one.id', 'ASC')])
|
|
self.assertTrue(all(x.many2one.id <= y.many2one.id
|
|
for x, y in zip(search, search[1:])))
|
|
|
|
search = Many2oneOrderby.search([],
|
|
order=[('many2one.value', 'ASC')])
|
|
self.assertTrue(all(x.many2one.value <= y.many2one.value
|
|
for x, y in zip(search, search[1:])))
|
|
|
|
transaction.rollback()
|
|
|
|
target1, target2 = Many2oneTarget.create([
|
|
{'value': 1},
|
|
{'value': 2},
|
|
])
|
|
|
|
search1, search2 = Many2oneSearch.create([
|
|
{'many2one': target1.id},
|
|
{'many2one': target2.id},
|
|
])
|
|
|
|
# Search join
|
|
Many2oneSearch.target_search = 'join'
|
|
self.assertEqual(Many2oneSearch.search([
|
|
('many2one.value', '=', 1),
|
|
]), [search1])
|
|
|
|
# Search subquery
|
|
Many2oneSearch.target_search = 'subquery'
|
|
self.assertEqual(Many2oneSearch.search([
|
|
('many2one.value', '=', 1),
|
|
]), [search1])
|
|
|
|
transaction.rollback()
|
|
|
|
for model in ['test.many2one_tree', 'test.many2one_mptt']:
|
|
pool = Pool()
|
|
Many2One = pool.get(model)
|
|
|
|
root1, root2 = Many2One.create([{}, {}])
|
|
first1, first2, first3, first4 = Many2One.create([
|
|
{'many2one': root1.id},
|
|
{'many2one': root1.id},
|
|
{'many2one': root2.id},
|
|
{'many2one': root2.id},
|
|
])
|
|
second1, second2, second3, second4 = Many2One.create([
|
|
{'many2one': first1.id},
|
|
{'many2one': first1.id},
|
|
{'many2one': first2.id},
|
|
{'many2one': first2.id},
|
|
])
|
|
all_ = Many2One.search([])
|
|
|
|
def not_(l):
|
|
return [r for r in all_ if r not in l]
|
|
|
|
for clause, test in [
|
|
([root1.id], [root1, first1, first2,
|
|
second1, second2, second3, second4]),
|
|
([second1.id], [second1]),
|
|
([root2.id], [root2, first3, first4]),
|
|
([first2.id, first3.id], [first2, first3,
|
|
second3, second4]),
|
|
([], []),
|
|
]:
|
|
result = Many2One.search(
|
|
[('many2one', 'child_of', clause)])
|
|
self.assertEqual(result, test)
|
|
|
|
result = Many2One.search(
|
|
[('many2one', 'not child_of', clause)])
|
|
self.assertEqual(result, not_(test))
|
|
|
|
for clause, test in [
|
|
([root1.id], [root1]),
|
|
([first3.id], [root2, first3]),
|
|
([second4.id], [root1, first2, second4]),
|
|
([second4.id, first4.id], [root1, root2,
|
|
first2, first4, second4]),
|
|
([], []),
|
|
]:
|
|
result = Many2One.search(
|
|
[('many2one', 'parent_of', clause)])
|
|
self.assertEqual(result, test)
|
|
|
|
result = Many2One.search(
|
|
[('many2one', 'not parent_of', clause)])
|
|
self.assertEqual(result, not_(test))
|
|
|
|
transaction.rollback()
|
|
|
|
@with_transaction()
|
|
def test_timedelta(self):
|
|
'Test timedelta'
|
|
pool = Pool()
|
|
Timedelta = pool.get('test.timedelta')
|
|
TimedeltaDefault = pool.get('test.timedelta_default')
|
|
TimedeltaRequired = pool.get('test.timedelta_required')
|
|
transaction = Transaction()
|
|
|
|
minute = datetime.timedelta(minutes=1)
|
|
hour = datetime.timedelta(hours=1)
|
|
day = datetime.timedelta(days=1)
|
|
default_timedelta = datetime.timedelta(seconds=3600)
|
|
|
|
timedelta1, = Timedelta.create([{
|
|
'timedelta': hour,
|
|
}])
|
|
self.assert_(timedelta1)
|
|
self.assertEqual(timedelta1.timedelta, hour)
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '=', hour),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '=', day),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '=', None),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '!=', day),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '!=', None),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', [hour]),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', [day]),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', [minute]),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', [None]),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', []),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'not in', [hour]),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'not in', [day]),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'not in', [None]),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'not in', []),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<', day),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<', minute),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<', hour),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<=', hour),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<=', minute),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '<=', day),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>', day),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>', minute),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>', hour),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>=', day),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>=', minute),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '>=', hour),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1])
|
|
|
|
timedelta2, = Timedelta.create([{
|
|
'timedelta': minute,
|
|
}])
|
|
self.assert_(timedelta2)
|
|
self.assertEqual(timedelta2.timedelta, minute)
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', '=', minute),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta2])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'in', [minute, hour]),
|
|
])
|
|
self.assertEqual(timedelta, [timedelta1, timedelta2])
|
|
|
|
timedelta = Timedelta.search([
|
|
('timedelta', 'not in', [minute, hour]),
|
|
])
|
|
self.assertEqual(timedelta, [])
|
|
|
|
timedelta3, = Timedelta.create([{}])
|
|
self.assert_(timedelta3)
|
|
self.assertEqual(timedelta3.timedelta, None)
|
|
|
|
timedelta4, = TimedeltaDefault.create([{}])
|
|
self.assert_(timedelta4)
|
|
self.assertEqual(timedelta4.timedelta, default_timedelta)
|
|
|
|
Timedelta.write([timedelta1], {
|
|
'timedelta': minute,
|
|
})
|
|
self.assertEqual(timedelta1.timedelta, minute)
|
|
|
|
Timedelta.write([timedelta2], {
|
|
'timedelta': day,
|
|
})
|
|
self.assertEqual(timedelta2.timedelta, day)
|
|
|
|
self.assertRaises(Exception, Timedelta.create, [{
|
|
'timedelta': 'test',
|
|
}])
|
|
|
|
self.assertRaises(Exception, Timedelta.write, [timedelta1], {
|
|
'timedelta': 'test',
|
|
})
|
|
|
|
self.assertRaises(Exception, Timedelta.create, [{
|
|
'timedelta': 1,
|
|
}])
|
|
|
|
self.assertRaises(Exception, Timedelta.write, [timedelta1], {
|
|
'timedelta': 1,
|
|
})
|
|
|
|
self.assertRaises(UserError, TimedeltaRequired.create, [{}])
|
|
transaction.rollback()
|
|
|
|
timedelta6, = TimedeltaRequired.create([{
|
|
'timedelta': day,
|
|
}])
|
|
self.assert_(timedelta6)
|
|
|
|
timedelta7, = Timedelta.create([{
|
|
'timedelta': None,
|
|
}])
|
|
self.assert_(timedelta7)
|
|
|
|
|
|
def suite():
|
|
return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase)
|