# -*- 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 from trytond.exceptions import UserError class FieldsTestCase(unittest.TestCase): 'Test Fields' def setUp(self): install_module('tests') 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.integer_domain = POOL.get('test.integer_domain') 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.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.one2one_domain = POOL.get('test.one2one_domain') 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') self.selection = POOL.get('test.selection') self.selection_required = POOL.get('test.selection_required') self.dict_ = POOL.get('test.dict') self.dict_default = POOL.get('test.dict_default') self.dict_required = POOL.get('test.dict_required') self.binary = POOL.get('test.binary') self.binary_default = POOL.get('test.binary_default') self.binary_required = POOL.get('test.binary_required') self.m2o_domain_validation = POOL.get('test.many2one_domainvalidation') self.m2o_target = POOL.get('test.many2one_target') 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.assertTrue(boolean4.boolean) 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 test0021integer(self): 'Test Integer with domain' with Transaction().start(DB_NAME, USER, context=CONTEXT): self.integer_domain.create([{ 'integer': 100, }]) self.assertRaises(UserError, self.integer_domain.create, [{ 'integer': 10, }]) 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 test0041numeric(self): 'Test numeric search cast' with Transaction().start(DB_NAME, USER, context=CONTEXT): numeric1, numeric2 = self.numeric.create([{ 'numeric': Decimal('1.1'), }, { 'numeric': Decimal('100.0'), }]) numerics = self.numeric.search([ ('numeric', '<', Decimal('5')), ]) self.assertEqual(numerics, [numeric1]) 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 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) 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) target4, = self.one2one_target.create([{ 'name': 'target4', }]) self.assertRaises(Exception, self.one2one_domain.create, [{ 'name': 'one2one4', 'one2one': target4.id, }]) transaction.cursor.rollback() target5, = self.one2one_target.create([{ 'name': 'domain', }]) one2one5, = self.one2one_domain.create([{ 'name': 'one2one5', 'one2one': target5.id, }]) 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': [ ('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.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': [ ('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.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)]) 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', '=', (target1.__name__, target1.id)), ]) self.assertEqual(references, [reference1]) references = self.reference.search([ ('reference', '=', [target1.__name__, target1.id]), ]) self.assertEqual(references, [reference1]) references = self.reference.search([ ('reference.name', '=', 'target1', 'test.reference.target'), ]) 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 test0160selection(self): 'Test Selection' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: selection1, = self.selection.create([{'select': 'arabic'}]) self.assert_(selection1) self.assertEqual(selection1.select, 'arabic') selection2, = self.selection.create([{'select': None}]) self.assert_(selection2) self.assertEqual(selection2.select, None) self.assertRaises(Exception, self.selection.create, [{'select': 'chinese'}]) selection3, = self.selection.create( [{'select': 'arabic', 'dyn_select': '1'}]) self.assert_(selection3) self.assertEqual(selection3.select, 'arabic') self.assertEqual(selection3.dyn_select, '1') selection4, = self.selection.create( [{'select': 'hexa', 'dyn_select': '0x3'}]) self.assert_(selection4) self.assertEqual(selection4.select, 'hexa') self.assertEqual(selection4.dyn_select, '0x3') selection5, = self.selection.create( [{'select': 'hexa', 'dyn_select': None}]) self.assert_(selection5) self.assertEqual(selection5.select, 'hexa') self.assertEqual(selection5.dyn_select, None) self.assertRaises(Exception, self.selection.create, [{'select': 'arabic', 'dyn_select': '0x3'}]) self.assertRaises(Exception, self.selection.create, [{'select': 'hexa', 'dyn_select': '3'}]) self.assertRaises(Exception, self.selection_required.create, [{}]) transaction.cursor.rollback() self.assertRaises(Exception, self.selection_required.create, [{'select': None}]) transaction.cursor.rollback() selection6, = self.selection_required.create([{'select': 'latin'}]) self.assert_(selection6) self.assertEqual(selection6.select, 'latin') def test0170dict(self): 'Test Dict' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: dict1, = self.dict_.create([{ 'dico': {'a': 1, 'b': 2}, }]) self.assert_(dict1.dico == {'a': 1, 'b': 2}) self.dict_.write([dict1], {'dico': {'z': 26}}) self.assert_(dict1.dico == {'z': 26}) dict2, = self.dict_.create([{}]) self.assert_(dict2.dico is None) dict3, = self.dict_default.create([{}]) self.assert_(dict3.dico == {'a': 1}) self.assertRaises(Exception, self.dict_required.create, [{}]) transaction.cursor.rollback() dict4, = self.dict_required.create([{'dico': dict(a=1)}]) self.assert_(dict4.dico == {'a': 1}) self.assertRaises(Exception, self.dict_required.create, [{'dico': {}}]) transaction.cursor.rollback() def test0180binary(self): 'Test Binary' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: bin1, = self.binary.create([{ 'binary': buffer('foo'), }]) self.assert_(bin1.binary == buffer('foo')) self.binary.write([bin1], {'binary': buffer('bar')}) self.assert_(bin1.binary == buffer('bar')) with transaction.set_context({'test.binary.binary': 'size'}): bin1_size = self.binary(bin1.id) self.assert_(bin1_size.binary == len('bar')) self.assert_(bin1_size.binary != buffer('bar')) bin2, = self.binary.create([{}]) self.assert_(bin2.binary is None) bin3, = self.binary_default.create([{}]) self.assert_(bin3.binary == buffer('default')) self.assertRaises(Exception, self.binary_required.create, [{}]) transaction.cursor.rollback() bin4, = self.binary_required.create([{'binary': buffer('baz')}]) self.assert_(bin4.binary == buffer('baz')) self.assertRaises(Exception, self.binary_required.create, [{'binary': buffer('')}]) transaction.cursor.rollback() def test0190many2one(self): 'Test Many2One' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: # Not respecting the domain raise an Error m2o_1, = self.m2o_target.create([{'value': 1}]) self.assertRaises(UserError, self.m2o_domain_validation.create, [{'many2one': m2o_1}]) # Respecting the domain works m2o_6, = self.m2o_target.create([{'value': 6}]) domain, = self.m2o_domain_validation.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() transaction.cursor.rollback() def suite(): return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase)