284 lines
9.1 KiB
Python
Executable File
284 lines
9.1 KiB
Python
Executable File
# 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 unittest
|
|
|
|
from trytond.model.exceptions import (
|
|
RequiredValidationError, SelectionValidationError)
|
|
from trytond.pool import Pool
|
|
from trytond.tests.test_tryton import activate_module, with_transaction
|
|
|
|
|
|
class FieldSelectionTestCase(unittest.TestCase):
|
|
"Test Field Selection"
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
activate_module('tests')
|
|
|
|
@with_transaction()
|
|
def test_create(self):
|
|
"Test create selection"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection, selection_none = Selection.create([{
|
|
'select': 'arabic',
|
|
}, {
|
|
'select': None,
|
|
}])
|
|
|
|
self.assertEqual(selection.select, 'arabic')
|
|
self.assertEqual(selection_none.select, None)
|
|
|
|
@with_transaction()
|
|
def test_create_not_in(self):
|
|
"Test create selection not in selection"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
with self.assertRaises(SelectionValidationError):
|
|
Selection.create([{
|
|
'select': 'chinese',
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_create_dynamic(self):
|
|
"Test create dynamic selection"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection_arabic, selection_hexa = Selection.create([{
|
|
'select': 'arabic',
|
|
'dyn_select': '1',
|
|
}, {
|
|
'select': 'hexa',
|
|
'dyn_select': '0x3',
|
|
}])
|
|
|
|
self.assertEqual(selection_arabic.dyn_select, '1')
|
|
self.assertEqual(selection_hexa.dyn_select, '0x3')
|
|
|
|
@with_transaction()
|
|
def test_create_dynamic_none(self):
|
|
"Test create dynamic selection None"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection, = Selection.create([{
|
|
'select': 'hexa',
|
|
'dyn_select': None,
|
|
}])
|
|
|
|
self.assertEqual(selection.dyn_select, None)
|
|
|
|
@with_transaction()
|
|
def test_create_dynamic_static(self):
|
|
"Test create dynamic selection static"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection, = Selection.create([{
|
|
'dyn_select_static': '1',
|
|
}])
|
|
|
|
self.assertEqual(selection.dyn_select_static, '1')
|
|
|
|
@with_transaction()
|
|
def test_create_dynamic_not_in(self):
|
|
"Test create selection not in"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
with self.assertRaises(SelectionValidationError):
|
|
Selection.create([{
|
|
'select': 'arabic',
|
|
'dyn_select': '0x3',
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_create_required_with_value(self):
|
|
"Test create selection required with value"
|
|
Selection = Pool().get('test.selection_required')
|
|
|
|
selection, = Selection.create([{
|
|
'select': 'latin',
|
|
}])
|
|
|
|
self.assertEqual(selection.select, 'latin')
|
|
|
|
@with_transaction()
|
|
def test_create_required_without_value(self):
|
|
"Test create selection required without value"
|
|
Selection = Pool().get('test.selection_required')
|
|
|
|
with self.assertRaises(RequiredValidationError):
|
|
Selection.create([{}])
|
|
|
|
@with_transaction()
|
|
def test_create_required_none(self):
|
|
"Test create selection required without value"
|
|
Selection = Pool().get('test.selection_required')
|
|
|
|
with self.assertRaises(RequiredValidationError):
|
|
Selection.create([{
|
|
'select': None,
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_search_order_label(self):
|
|
"Test search order by label"
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection_label')
|
|
|
|
Selection.create([{'select': v} for v in ['a', 'b', 'c']])
|
|
records = Selection.search([], order=[('select', 'ASC')])
|
|
values = [r.select for r in records]
|
|
|
|
self.assertListEqual(values, ['c', 'b', 'a'])
|
|
|
|
@with_transaction()
|
|
def test_search_order_fixed_selection(self):
|
|
"Test search order by fixed selection"
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection')
|
|
|
|
Selection.create([{'select': v} for v in ['', 'arabic', 'hexa']])
|
|
records = Selection.search([], order=[('select', 'DESC')])
|
|
values = [r.select for r in records]
|
|
|
|
self.assertListEqual(values, ['hexa', 'arabic', ''])
|
|
|
|
@with_transaction()
|
|
def test_search_order_static_selection(self):
|
|
"Test search order by static selection"
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection')
|
|
|
|
Selection.create([
|
|
{'dyn_select_static': str(i)} for i in range(1, 4)])
|
|
records = Selection.search([], order=[('dyn_select_static', 'DESC')])
|
|
values = [r.dyn_select_static for r in records]
|
|
|
|
self.assertListEqual(values, ['3', '2', '1'])
|
|
|
|
@with_transaction()
|
|
def test_search_order_dynamic_selection(self):
|
|
"Test search order by dynamic selection"
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection')
|
|
|
|
Selection.create([
|
|
{'select': 'arabic', 'dyn_select': str(i)}
|
|
for i in range(1, 4)])
|
|
Selection.create([
|
|
{'select': 'hexa', 'dyn_select': hex(i)}
|
|
for i in range(1, 4)])
|
|
records = Selection.search([], order=[('dyn_select', 'DESC')])
|
|
values = [r.dyn_select for r in records]
|
|
|
|
self.assertListEqual(values, ['3', '2', '1', '0x3', '0x2', '0x1'])
|
|
|
|
@with_transaction()
|
|
def test_search_order_unsorted(self):
|
|
"Test search order with unsorted selection"
|
|
pool = Pool()
|
|
Selection = pool.get('test.selection')
|
|
|
|
Selection.create([{
|
|
'unsorted_select': 'second',
|
|
}, {
|
|
'unsorted_select': 'last',
|
|
}, {
|
|
'unsorted_select': 'first',
|
|
}])
|
|
|
|
records = Selection.search([], order=[('unsorted_select', 'ASC')])
|
|
values = [r.unsorted_select for r in records]
|
|
|
|
self.assertListEqual(values, ['first', 'second', 'last'])
|
|
|
|
@with_transaction()
|
|
def test_string(self):
|
|
"Test string selection"
|
|
Selection = Pool().get('test.selection')
|
|
selection, selection_none = Selection.create([{
|
|
'select': 'arabic',
|
|
}, {
|
|
'select': None,
|
|
}])
|
|
|
|
self.assertEqual(selection.select_string, 'Arabic')
|
|
self.assertEqual(selection_none.select_string, '')
|
|
|
|
@with_transaction()
|
|
def test_string_dynamic(self):
|
|
"Test string dynamic selection"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection_arabic, selection_hexa = Selection.create([{
|
|
'select': 'arabic',
|
|
'dyn_select': '1',
|
|
}, {
|
|
'select': 'hexa',
|
|
'dyn_select': '0x3',
|
|
}])
|
|
|
|
self.assertEqual(selection_arabic.dyn_select_string, '1')
|
|
self.assertEqual(selection_hexa.dyn_select_string, '0x3')
|
|
|
|
@with_transaction()
|
|
def test_string_dynamic_none(self):
|
|
"Test string dynamic selection None"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection, = Selection.create([{
|
|
'select': 'hexa',
|
|
'dyn_select': None,
|
|
}])
|
|
|
|
self.assertEqual(selection.dyn_select_string, '')
|
|
|
|
@with_transaction()
|
|
def test_string_dynamic_selection_static(self):
|
|
"Test string dynamic selection static"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
selection, = Selection.create([{
|
|
'dyn_select_static': '1',
|
|
}])
|
|
|
|
self.assertEqual(selection.dyn_select_static_string, '1')
|
|
|
|
@with_transaction()
|
|
def test_read_string(self):
|
|
"Test reading value and string"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
arabic, null = Selection.create([
|
|
{
|
|
'select': 'arabic',
|
|
},
|
|
{
|
|
'select': None,
|
|
},
|
|
])
|
|
arabic_read, null_read = Selection.read(
|
|
[arabic.id, null.id], ['select:string'])
|
|
|
|
self.assertEqual(arabic_read['select:string'], 'Arabic')
|
|
self.assertEqual(null_read['select:string'], '')
|
|
|
|
@with_transaction()
|
|
def test_read_string_dynamic_selection(self):
|
|
"Test reading value and string of dynamic selection"
|
|
Selection = Pool().get('test.selection')
|
|
|
|
one, null = Selection.create([
|
|
{
|
|
'select': 'arabic',
|
|
'dyn_select': '1'
|
|
},
|
|
{
|
|
'select': None,
|
|
},
|
|
])
|
|
one_read, null_read = Selection.read(
|
|
[one.id, null.id], ['dyn_select:string'])
|
|
|
|
self.assertEqual(one_read['dyn_select:string'], '1')
|
|
self.assertEqual(null_read['dyn_select:string'], '')
|