Odoo18-Base/odoo/addons/test_impex/tests/test_export.py
2025-03-10 10:52:11 +07:00

756 lines
23 KiB
Python

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
import itertools
import pstats
from cProfile import Profile
from odoo import fields, Command
from odoo.tests import common
class CreatorCase(common.TransactionCase):
model_name = False
def __init__(self, *args, **kwargs):
super(CreatorCase, self).__init__(*args, **kwargs)
self.model = None
def setUp(self):
super(CreatorCase, self).setUp()
self.model = self.env[self.model_name]
def make(self, value, context=None):
return self.model.with_context(**(context or {})).create({'value': value})
def export(self, value, fields=('value',), context=None):
record = self.make(value, context=context)
self.env.invalidate_all()
return record._export_rows([f.split('/') for f in fields])
class test_xids(CreatorCase):
model_name = 'export.boolean'
def test_no_module(self):
record = self.make(True)
# add existing xid without module
self.env['ir.model.data'].create({
'module': '',
'name': 'x',
'model': self.model_name,
'res_id': record.id,
})
self.env.invalidate_all()
self.assertEqual(
record._export_rows([['id'], ['value']]),
[[u'x', True]]
)
class test_boolean_field(CreatorCase):
model_name = 'export.boolean'
def test_true(self):
self.assertEqual(
self.export(True),
[[True]])
def test_false(self):
""" ``False`` value to boolean fields is unique in being exported as a
(unicode) string, not a boolean
"""
self.assertEqual(
self.export(False),
[[False]])
class test_integer_field(CreatorCase):
model_name = 'export.integer'
def test_empty(self):
self.assertEqual(self.model.search([]).ids, [],
"Test model should have no records")
def test_0(self):
self.assertEqual(
self.export(0),
[[0]])
def test_basic_value(self):
self.assertEqual(
self.export(42),
[[42]])
def test_negative(self):
self.assertEqual(
self.export(-32),
[[-32]])
def test_huge(self):
self.assertEqual(
self.export(2**31-1),
[[2147483647]])
class test_float_field(CreatorCase):
model_name = 'export.float'
def test_0(self):
self.assertEqual(
self.export(0.0),
[[0.0]])
def test_epsilon(self):
self.assertEqual(
self.export(0.000000000027),
[[0.000000000027]])
def test_negative(self):
self.assertEqual(
self.export(-2.42),
[[-2.42]])
def test_positive(self):
self.assertEqual(
self.export(47.36),
[[47.36]])
def test_big(self):
self.assertEqual(
self.export(87654321.4678),
[[87654321.4678]])
class test_decimal_field(CreatorCase):
model_name = 'export.decimal'
def test_0(self):
self.assertEqual(
self.export(0.0),
[[0.0]])
def test_epsilon(self):
""" epsilon gets sliced to 0 due to precision
"""
self.assertEqual(
self.export(0.000000000027),
[[0.0]])
def test_negative(self):
self.assertEqual(
self.export(-2.42),
[[-2.42]])
def test_positive(self):
self.assertEqual(
self.export(47.36),
[[47.36]])
def test_big(self):
self.assertEqual(
self.export(87654321.4678), [[87654321.468]])
class test_string_field(CreatorCase):
model_name = 'export.string.bounded'
def test_empty(self):
self.assertEqual(
self.export(""),
[['']])
def test_within_bounds(self):
self.assertEqual(
self.export("foobar"),
[[u"foobar"]])
def test_out_of_bounds(self):
self.assertEqual(
self.export("C for Sinking, "
"Java for Drinking, "
"Smalltalk for Thinking. "
"...and Power to the Penguin!"),
[[u"C for Sinking, J"]])
class test_unbound_string_field(CreatorCase):
model_name = 'export.string'
def test_empty(self):
self.assertEqual(
self.export(""),
[['']])
def test_small(self):
self.assertEqual(
self.export("foobar"),
[[u"foobar"]])
def test_big(self):
self.assertEqual(
self.export("We flew down weekly to meet with IBM, but they "
"thought the way to measure software was the amount "
"of code we wrote, when really the better the "
"software, the fewer lines of code."),
[[u"We flew down weekly to meet with IBM, but they thought the "
u"way to measure software was the amount of code we wrote, "
u"when really the better the software, the fewer lines of "
u"code."]])
class test_text(CreatorCase):
model_name = 'export.text'
def test_empty(self):
self.assertEqual(
self.export(""),
[['']])
def test_small(self):
self.assertEqual(
self.export("foobar"),
[[u"foobar"]])
def test_big(self):
self.assertEqual(
self.export("So, `bind' is `let' and monadic programming is"
" equivalent to programming in the A-normal form. That"
" is indeed all there is to monads"),
[[u"So, `bind' is `let' and monadic programming is equivalent to"
u" programming in the A-normal form. That is indeed all there"
u" is to monads"]])
def test_numeric(self):
self.assertEqual(
self.export(42),
[["42"]])
class test_date(CreatorCase):
model_name = 'export.date'
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_basic(self):
self.assertEqual(
self.export('2011-11-07'),
[[fields.Date.from_string('2011-11-07')]])
class test_datetime(CreatorCase):
model_name = 'export.datetime'
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_basic(self):
""" Export value with no TZ set on the user
"""
self.env.user.write({'tz': False})
self.assertEqual(
self.export('2011-11-07 21:05:48'),
[[fields.Datetime.from_string('2011-11-07 21:05:48')]])
def test_tz(self):
""" Export converts the value in the user's TZ
.. note:: on the other hand, export uses user lang for display_name
"""
self.assertEqual(
self.export('2011-11-07 21:05:48', context={'tz': 'Pacific/Norfolk'}),
[[fields.Datetime.from_string('2011-11-08 08:35:48')]])
class test_selection(CreatorCase):
model_name = 'export.selection'
translations_fr = [
("Qux", "toto"),
("Bar", "titi"),
("Foo", "tete"),
]
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_value(self):
""" selections export the *label* for their value
"""
self.assertEqual(
self.export('2'),
[[u"Bar"]])
def test_localized_export(self):
self.env['res.lang']._activate_lang('fr_FR')
ir_field = self.env['ir.model.fields']._get('export.selection', 'value')
selection = ir_field.selection_ids
translations = dict(self.translations_fr)
for sel_fr, sel in zip(selection.with_context(lang='fr_FR'), selection):
sel_fr.name = translations.get(sel.name, sel_fr.name)
self.assertEqual(
self.export('2', context={'lang': 'fr_FR'}),
[[u'titi']])
class test_selection_function(CreatorCase):
model_name = 'export.selection.function'
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_value(self):
# selection functions export the *value* itself
self.assertEqual(
self.export('1'),
[['1']])
self.assertEqual(
self.export('3'),
[['3']])
self.assertEqual(
self.export('0'),
[['0']])
class test_m2o(CreatorCase):
model_name = 'export.many2one'
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_basic(self):
""" Exported value is the display_name of the related object
"""
record = self.env['export.integer'].create({'value': 42})
self.assertEqual(
self.export(record.id),
[[record.display_name]])
def test_path(self):
""" Can recursively export fields of m2o via path
"""
record = self.env['export.integer'].create({'value': 42})
self.assertEqual(
self.export(record.id, fields=['value/.id', 'value/value']),
[[str(record.id), 42]])
def test_external_id(self):
record = self.env['export.integer'].create({'value': 42})
# Expecting the m2o target model name in the external id,
# not this model's name
self.assertRegex(
self.export(record.id, fields=['value/id'])[0][0],
u'__export__.export_integer_%d_[0-9a-f]{8}' % record.id)
def test_identical(self):
m2o = self.env['export.integer'].create({'value': 42}).id
records = \
( self.make(m2o)
| self.make(m2o)
| self.make(m2o)
| self.make(m2o)
)
self.env.invalidate_all()
xp = [r[0] for r in records._export_rows([['value', 'id']])]
self.assertEqual(len(xp), 4)
self.assertRegex(
xp[0],
u'__export__.export_integer_%d_[0-9a-f]{8}' % m2o
)
self.assertEqual(set(xp), {xp[0]})
class test_o2m(CreatorCase):
model_name = 'export.one2many'
commands = [
Command.create({'value': 4, 'str': 'record1'}),
Command.create({'value': 42, 'str': 'record2'}),
Command.create({'value': 36, 'str': 'record3'}),
Command.create({'value': 4, 'str': 'record4'}),
Command.create({'value': 13, 'str': 'record5'}),
]
names = [
u'export.one2many.child:%d' % d['value']
for c, _, d in commands
]
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_single(self):
self.assertEqual(
self.export([Command.create({'value': 42})]),
# display_name result
[[u'export.one2many.child:42']])
def test_single_subfield(self):
self.assertEqual(
self.export([Command.create({'value': 42})],
fields=['value', 'value/value']),
[[u'export.one2many.child:42', 42]])
def test_integrate_one_in_parent(self):
self.assertEqual(
self.export([Command.create({'value': 42})],
fields=['const', 'value/value']),
[[4, 42]])
def test_multiple_records(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value/value']),
[
[4, 4],
[u'', 42],
[u'', 36],
[u'', 4],
[u'', 13],
])
def test_multiple_records_name(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value']),
[
[4, u'export.one2many.child:4'],
[u'', u'export.one2many.child:42'],
[u'', u'export.one2many.child:36'],
[u'', u'export.one2many.child:4'],
[u'', u'export.one2many.child:13'],
])
def test_multiple_records_id(self):
export = self.export(self.commands, fields=['const', 'value/.id'])
records = self.env['export.one2many.child'].search([])
self.assertEqual(
export,
[
[4, str(records[0].id)],
['', str(records[1].id)],
['', str(records[2].id)],
['', str(records[3].id)],
['', str(records[4].id)],
])
def test_multiple_records_with_name_before(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value', 'value/value']),
[
[4, u'export.one2many.child:4', 4],
['', u'export.one2many.child:42', 42],
['', u'export.one2many.child:36', 36],
['', u'export.one2many.child:4', 4],
['', u'export.one2many.child:13', 13],
])
def test_multiple_records_with_name_after(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value/value', 'value']),
[
[4, 4, u'export.one2many.child:4'],
['', 42, u'export.one2many.child:42'],
['', 36, u'export.one2many.child:36'],
['', 4, u'export.one2many.child:4'],
['', 13, u'export.one2many.child:13'],
])
def test_multiple_subfields_neighbour(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value/str','value/value']),
[
[4, u'record1', 4],
['', u'record2', 42],
['', u'record3', 36],
['', u'record4', 4],
['', u'record5', 13],
])
def test_multiple_subfields_separated(self):
self.assertEqual(
self.export(self.commands, fields=['value/str', 'const', 'value/value']),
[
[u'record1', 4, 4],
[u'record2', '', 42],
[u'record3', '', 36],
[u'record4', '', 4],
[u'record5', '', 13],
])
class test_o2m_multiple(CreatorCase):
model_name = 'export.one2many.multiple'
def make(self, value=None, **values):
if value is not None:
values['value'] = value
return self.model.create(values)
def export(self, value=None, fields=('child1', 'child2',), context=None, **values):
record = self.make(value, **values)
return record._export_rows([f.split('/') for f in fields])
def test_empty(self):
self.assertEqual(
self.export(child1=False, child2=False),
[['', '']])
def test_single_per_side(self):
self.assertEqual(
self.export(child1=False, child2=[Command.create({'value': 42})]),
[['', u'export.one2many.child.2:42']])
self.assertEqual(
self.export(child1=[Command.create({'value': 43})], child2=False),
[[u'export.one2many.child.1:43', '']])
self.assertEqual(
self.export(child1=[Command.create({'value': 43})],
child2=[Command.create({'value': 42})]),
[[u'export.one2many.child.1:43', u'export.one2many.child.2:42']])
def test_single_integrate_subfield(self):
fields = ['const', 'child1/value', 'child2/value']
self.assertEqual(
self.export(child1=False, child2=[Command.create({'value': 42})],
fields=fields),
[[36, '', 42]])
self.assertEqual(
self.export(child1=[Command.create({'value': 43})], child2=False,
fields=fields),
[[36, 43, '']])
self.assertEqual(
self.export(child1=[Command.create({'value': 43})],
child2=[Command.create({'value': 42})],
fields=fields),
[[36, 43, 42]])
def test_multiple(self):
""" With two "concurrent" o2ms, exports the first line combined, then
exports the rows for the first o2m, then the rows for the second o2m.
"""
fields = ['const', 'child1/value', 'child2/value']
child1 = [Command.create({'value': v, 'str': 'record%.02d' % index})
for index, v in zip(itertools.count(), [4, 42, 36, 4, 13])]
child2 = [Command.create({'value': v, 'str': 'record%.02d' % index})
for index, v in zip(itertools.count(10), [8, 12, 8, 55, 33, 13])]
self.assertEqual(
self.export(child1=child1, child2=False, fields=fields),
[
[36, 4, ''],
['', 42, ''],
['', 36, ''],
['', 4, ''],
['', 13, ''],
])
self.assertEqual(
self.export(child1=False, child2=child2, fields=fields),
[
[36, '', 8],
['', '', 12],
['', '', 8],
['', '', 55],
['', '', 33],
['', '', 13],
])
self.assertEqual(
self.export(child1=child1, child2=child2, fields=fields),
[
[36, 4, 8],
['', 42, ''],
['', 36, ''],
['', 4, ''],
['', 13, ''],
['', '', 12],
['', '', 8],
['', '', 55],
['', '', 33],
['', '', 13],
])
class test_m2m(CreatorCase):
model_name = 'export.many2many'
commands = [
Command.create({'value': 4, 'str': 'record000'}),
Command.create({'value': 42, 'str': 'record001'}),
Command.create({'value': 36, 'str': 'record010'}),
Command.create({'value': 4, 'str': 'record011'}),
Command.create({'value': 13, 'str': 'record100'}),
]
names = [
u'export.many2many.other:%d' % d['value']
for c, _, d in commands
]
def test_empty(self):
self.assertEqual(
self.export(False),
[['']])
def test_single(self):
self.assertEqual(
self.export([Command.create({'value': 42})]),
# display_name result
[[u'export.many2many.other:42']])
def test_single_subfield(self):
self.assertEqual(
self.export([Command.create({'value': 42})],
fields=['value', 'value/value'],
context={'import_compat': False}),
[[u'export.many2many.other:42', 42]])
def test_integrate_one_in_parent(self):
self.assertEqual(
self.export([Command.create({'value': 42})],
fields=['const', 'value/value'],
context={'import_compat': False}),
[[4, 42]])
def test_multiple_records(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value/value'], context={'import_compat': False}),
[
[4, 4],
[u'', 42],
[u'', 36],
[u'', 4],
[u'', 13],
])
def test_multiple_records_name(self):
self.assertEqual(
self.export(self.commands, fields=['const', 'value']),
[
[4, 'export.many2many.other:4,export.many2many.other:42,export.many2many.other:36,export.many2many.other:4,export.many2many.other:13'],
])
self.assertEqual(
self.export(self.commands, fields=['const', 'value'], context={'import_compat': False}),
[
[4, u'export.many2many.other:4'],
['', u'export.many2many.other:42'],
['', u'export.many2many.other:36'],
['', u'export.many2many.other:4'],
['', u'export.many2many.other:13'],
])
def test_multiple_records_subfield(self):
r = self.make(self.commands)
xid = self.env['ir.model.data'].create({
'name': 'whopwhopwhop',
'module': '__t__',
'model': r._name,
'res_id': r.id,
}).complete_name
sids = [
self.env['ir.model.data'].create({
'name': sub.str,
'module': '__t__',
'model': sub._name,
'res_id': sub.id,
}).complete_name
for sub in r.value
]
self.env.invalidate_all()
self.assertEqual(
r._export_rows([['value', 'id']]),
[['__t__.record000,__t__.record001,__t__.record010,__t__.record011,__t__.record100']]
)
self.assertEqual(
r.with_context(import_compat=True)._export_rows([['value', 'id']]),
[['__t__.record000,__t__.record001,__t__.record010,__t__.record011,__t__.record100']]
)
self.assertEqual(
r.with_context(import_compat=True)._export_rows([['value'], ['value', 'id']]),
[['', '__t__.record000,__t__.record001,__t__.record010,__t__.record011,__t__.record100']]
)
self.assertEqual(
r.with_context(import_compat=False)._export_rows([['id'], ['value', 'id'], ['value', 'value']]),
[
[xid, u'__t__.record000', 4],
[u'', u'__t__.record001', 42],
[u'', u'__t__.record010', 36],
[u'', u'__t__.record011', 4],
[u'', u'__t__.record100', 13]
]
)
self.assertEqual(
r.with_context(import_compat=False)._export_rows([['id'], ['value', 'value'], ['value', 'id']]),
[
[xid, 4, u'__t__.record000'],
[u'', 42, u'__t__.record001'],
[u'', 36, u'__t__.record010'],
[u'', 4, u'__t__.record011'],
[u'', 13, u'__t__.record100']
]
)
class test_function(CreatorCase):
model_name = 'export.function'
def test_value(self):
""" Exports value normally returned by accessing the function field
"""
self.assertEqual(
self.export(42),
[[3]])
@common.tagged('-standard', 'bench')
class test_xid_perfs(common.TransactionCase):
def setUp(self):
super(test_xid_perfs, self).setUp()
self.profile = Profile()
@self.addCleanup
def _dump():
stats = pstats.Stats(self.profile)
stats.strip_dirs()
stats.sort_stats('cumtime')
stats.print_stats(20)
self.profile = None
def test_basic(self):
Model = self.env['export.integer']
for i in range(10000):
Model.create({'value': i})
self.env.invalidate_all()
records = Model.search([])
self.profile.runcall(records._export_rows, [['id'], ['value']])
def test_m2o_single(self):
rid = self.env['export.integer'].create({'value': 42}).id
Model = self.env['export.many2one']
for _ in range(10000):
Model.create({'value': rid})
self.env.invalidate_all()
records = Model.search([])
self.profile.runcall(records._export_rows, [['id'], ['value','id']])
def test_m2o_each(self):
Model = self.env['export.many2one']
Integer = self.env['export.integer']
for i in range(10000):
Model.create({
'value': Integer.create({'value': i}).id
})
self.env.invalidate_all()
records = Model.search([])
self.profile.runcall(records._export_rows, [['id'], ['value', 'id']])