From 20741b613d8d59dadd4187784c4fddb17eace2b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Krier?= Date: Thu, 4 Mar 2010 14:02:27 +0100 Subject: [PATCH] Improve unittests to run trytond from tests Use sqlite as default backend Add skiptest attribute to data tag Add option to test_tryton to run tests from all modules --- CHANGELOG | 4 + etc/trytond.conf | 2 +- trytond/backend/sqlite/database.py | 7 +- trytond/config.py | 4 +- trytond/ir/module/module.xml | 2 +- trytond/modules/__init__.py | 14 +- trytond/pool.py | 1 + trytond/test/__init__.py | 7 + trytond/{tests => test}/__tryton__.py | 0 trytond/{tests => test}/import_data.py | 52 +- trytond/{tests => test}/import_data.xml | 22 +- trytond/{tests => test}/model.py | 2 +- trytond/{tests => test}/mptt.py | 6 +- trytond/{tests/tests.py => test/test.py} | 56 +- trytond/tests/__init__.py | 5 - trytond/tests/test_fields.py | 2053 +++++++++++++ trytond/tests/test_importdata.py | 415 +++ trytond/tests/test_modelsingleton.py | 155 + trytond/tests/test_mptt.py | 224 ++ trytond/tests/test_pyson.py | 545 ++++ trytond/tests/test_tools.py | 102 + trytond/tests/test_tryton.py | 3421 +--------------------- trytond/tools/convert.py | 10 +- trytond/tools/misc.py | 2 +- 24 files changed, 3760 insertions(+), 3351 deletions(-) create mode 100644 trytond/test/__init__.py rename trytond/{tests => test}/__tryton__.py (100%) rename trytond/{tests => test}/import_data.py (70%) rename trytond/{tests => test}/import_data.xml (70%) rename trytond/{tests => test}/model.py (93%) rename trytond/{tests => test}/mptt.py (86%) rename trytond/{tests/tests.py => test/test.py} (87%) create mode 100644 trytond/tests/test_fields.py create mode 100644 trytond/tests/test_importdata.py create mode 100644 trytond/tests/test_modelsingleton.py create mode 100644 trytond/tests/test_mptt.py create mode 100644 trytond/tests/test_pyson.py create mode 100644 trytond/tests/test_tools.py diff --git a/CHANGELOG b/CHANGELOG index e832365108..2792fd89e5 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,7 @@ +* Improve unittests to run trytond from tests + Use sqlite as default backend + Add skiptest attribute to data tag + Add option to test_tryton to run tests from all modules * Add MySQL backend * Refactoring by validation with pylint * Modify ondelete attribute of Many2One according to required attribute value diff --git a/etc/trytond.conf b/etc/trytond.conf index 855ba8232d..4d564cb406 100644 --- a/etc/trytond.conf +++ b/etc/trytond.conf @@ -30,7 +30,7 @@ # Configure the database type # allowed values are postgresql, sqlite, mysql -db_type = postgresql +#db_type = postgresql # Configure the database connection ## Note: Only databases owned by db_user will be displayed in the connection dialog diff --git a/trytond/backend/sqlite/database.py b/trytond/backend/sqlite/database.py index 393170ac89..0e43b4081a 100644 --- a/trytond/backend/sqlite/database.py +++ b/trytond/backend/sqlite/database.py @@ -179,7 +179,12 @@ class Database(DatabaseInterface): @staticmethod def list(cursor): res = [] - for db_file in os.listdir(CONFIG['data_path']) + [':memory:']: + listdir = [':memory:'] + try: + listdir += os.listdir(CONFIG['data_path']) + except OSError: + pass + for db_file in listdir: if db_file.endswith('.sqlite') or db_file == ':memory:': if db_file == ':memory:': db_name = ':memory:' diff --git a/trytond/config.py b/trytond/config.py index a70beefb57..af26deee1b 100644 --- a/trytond/config.py +++ b/trytond/config.py @@ -119,14 +119,14 @@ class ConfigManager(object): init = {} if opt.init: for i in opt.init.split(','): - if i != 'tests': + if i != 'test': init[i] = 1 self.options['init'] = init update = {} if opt.update: for i in opt.update.split(','): - if i != 'tests': + if i != 'test': update[i] = 1 self.options['update'] = update diff --git a/trytond/ir/module/module.xml b/trytond/ir/module/module.xml index d62f47b637..5373dbb426 100644 --- a/trytond/ir/module/module.xml +++ b/trytond/ir/module/module.xml @@ -77,7 +77,7 @@ this repository contains the full copyright notices and license terms. --> ir.action.act_window ir.module.module form - [('name', '!=', 'tests')] + [('name', '!=', 'test')] diff --git a/trytond/modules/__init__.py b/trytond/modules/__init__.py index 659d30fcef..1132f4cc51 100644 --- a/trytond/modules/__init__.py +++ b/trytond/modules/__init__.py @@ -133,7 +133,7 @@ def create_graph(module_list, force=None): for module in module_list: tryton_file = OPJ(MODULES_PATH, module, '__tryton__.py') mod_path = OPJ(MODULES_PATH, module) - if module in ('ir', 'workflow', 'res', 'webdav', 'tests'): + if module in ('ir', 'workflow', 'res', 'webdav', 'test'): root_path = os.path.dirname(os.path.dirname(__file__)) tryton_file = OPJ(root_path, module, '__tryton__.py') mod_path = OPJ(root_path, module) @@ -171,7 +171,7 @@ def create_graph(module_list, force=None): for kind in ('init', 'update'): if (package in CONFIG[kind]) \ or (('all' in CONFIG[kind]) \ - and (package != 'tests')) \ + and (package != 'test')) \ or (kind in force): setattr(node, kind, True) else: @@ -314,7 +314,7 @@ def get_module_list(): module_list.add('workflow') module_list.add('res') module_list.add('webdav') - module_list.add('tests') + module_list.add('test') return list(module_list) def register_classes(reload_p=False): @@ -328,11 +328,11 @@ def register_classes(reload_p=False): import trytond.workflow import trytond.res import trytond.webdav - import trytond.tests + import trytond.test else: for module in ('trytond.model', 'trytond.report', 'trytond.wizard', 'trytond.ir', 'trytond.workflow', 'trytond.res', - 'trytond.webdav', 'trytond.tests'): + 'trytond.webdav', 'trytond.test'): for i in sys.modules.keys(): if i.startswith(module) \ and i != module: @@ -345,7 +345,7 @@ def register_classes(reload_p=False): module = package.name logger.info('%s:registering classes' % module) - if module in ('ir', 'workflow', 'res', 'webdav', 'tests'): + if module in ('ir', 'workflow', 'res', 'webdav', 'test'): MODULES.append(module) continue @@ -396,7 +396,7 @@ def load_modules(database_name, pool, update=False, lang=None): if update: if 'all' in CONFIG['init']: cursor.execute("SELECT name FROM ir_module_module " \ - "WHERE name != \'tests\'") + "WHERE name != \'test\'") else: cursor.execute("SELECT name FROM ir_module_module " \ "WHERE state IN ('installed', 'to install', " \ diff --git a/trytond/pool.py b/trytond/pool.py index c2ec48a388..eb54917529 100644 --- a/trytond/pool.py +++ b/trytond/pool.py @@ -16,6 +16,7 @@ class Pool(object): _locks = {} _pool = {} _pools = {} + test = False def __new__(cls, database_name): cls._lock.acquire() diff --git a/trytond/test/__init__.py b/trytond/test/__init__.py new file mode 100644 index 0000000000..f64dce2f96 --- /dev/null +++ b/trytond/test/__init__.py @@ -0,0 +1,7 @@ +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +from test import * +from model import * +from mptt import * +from import_data import * diff --git a/trytond/tests/__tryton__.py b/trytond/test/__tryton__.py similarity index 100% rename from trytond/tests/__tryton__.py rename to trytond/test/__tryton__.py diff --git a/trytond/tests/import_data.py b/trytond/test/import_data.py similarity index 70% rename from trytond/tests/import_data.py rename to trytond/test/import_data.py index 1580b5a8ff..f133b35dfb 100644 --- a/trytond/tests/import_data.py +++ b/trytond/test/import_data.py @@ -6,7 +6,7 @@ from trytond.model import ModelSQL, fields class ImportDataBoolean(ModelSQL): "Import Data Boolean" - _name = 'tests.import_data.boolean' + _name = 'test.import_data.boolean' _description = __doc__ boolean = fields.Boolean('Boolean') @@ -15,7 +15,7 @@ ImportDataBoolean() class ImportDataInteger(ModelSQL): "Import Data Integer" - _name = 'tests.import_data.integer' + _name = 'test.import_data.integer' _description = __doc__ integer = fields.Integer('Integer') @@ -24,7 +24,7 @@ ImportDataInteger() class ImportDataFloat(ModelSQL): "Import Data Float" - _name = 'tests.import_data.float' + _name = 'test.import_data.float' _description = __doc__ float = fields.Float('Float') @@ -33,7 +33,7 @@ ImportDataFloat() class ImportDataNumeric(ModelSQL): "Import Data Numeric" - _name = 'tests.import_data.numeric' + _name = 'test.import_data.numeric' _description = __doc__ numeric = fields.Numeric('Numeric') @@ -42,7 +42,7 @@ ImportDataNumeric() class ImportDataChar(ModelSQL): "Import Data Char" - _name = 'tests.import_data.char' + _name = 'test.import_data.char' _description = __doc__ char = fields.Char('Char') @@ -51,7 +51,7 @@ ImportDataChar() class ImportDataText(ModelSQL): "Import Data Text" - _name = 'tests.import_data.text' + _name = 'test.import_data.text' _description = __doc__ text = fields.Text('Text') @@ -60,7 +60,7 @@ ImportDataText() class ImportDataSha(ModelSQL): "Import Data Sha" - _name = 'tests.import_data.sha' + _name = 'test.import_data.sha' _description = __doc__ sha = fields.Sha('Sha') @@ -69,7 +69,7 @@ ImportDataSha() class ImportDataDate(ModelSQL): "Import Data Date" - _name = 'tests.import_data.date' + _name = 'test.import_data.date' _description = __doc__ date = fields.Date('Date') @@ -78,7 +78,7 @@ ImportDataDate() class ImportDataDateTime(ModelSQL): "Import Data DateTime" - _name = 'tests.import_data.datetime' + _name = 'test.import_data.datetime' _description = __doc__ datetime = fields.DateTime('DateTime') @@ -87,7 +87,7 @@ ImportDataDateTime() class ImportDataSelection(ModelSQL): "Import Data Selection" - _name = 'tests.import_data.selection' + _name = 'test.import_data.selection' _description = __doc__ selection = fields.Selection([ ('select1', 'Select 1'), @@ -100,7 +100,7 @@ ImportDataSelection() class ImportDataMany2OneTarget(ModelSQL): "Import Data Many2One Target" - _name = 'tests.import_data.many2one.target' + _name = 'test.import_data.many2one.target' _description = __doc__ name = fields.Char('Name') @@ -109,9 +109,9 @@ ImportDataMany2OneTarget() class ImportDataMany2One(ModelSQL): "Import Data Many2One" - _name = 'tests.import_data.many2one' + _name = 'test.import_data.many2one' _description = __doc__ - many2one = fields.Many2One('tests.import_data.many2one.target', + many2one = fields.Many2One('test.import_data.many2one.target', 'Many2One') ImportDataMany2One() @@ -119,7 +119,7 @@ ImportDataMany2One() class ImportDataMany2ManyTarget(ModelSQL): "Import Data Many2Many Target" - _name = 'tests.import_data.many2many.target' + _name = 'test.import_data.many2many.target' _description = __doc__ name = fields.Char('Name') @@ -128,9 +128,9 @@ ImportDataMany2ManyTarget() class ImportDataMany2Many(ModelSQL): "Import Data Many2Many" - _name = 'tests.import_data.many2many' + _name = 'test.import_data.many2many' _description = __doc__ - many2many = fields.Many2Many('tests.import_data.many2many.relation', + many2many = fields.Many2Many('test.import_data.many2many.relation', 'many2many', 'target', 'Many2Many') ImportDataMany2Many() @@ -138,19 +138,19 @@ ImportDataMany2Many() class ImportDataMany2ManyRelation(ModelSQL): "Import Data Many2Many Relation" - _name = 'tests.import_data.many2many.relation' - many2many = fields.Many2One('tests.import_data.many2many', 'Many2One') - target = fields.Many2One('tests.import_data.many2many.target', 'Target') + _name = 'test.import_data.many2many.relation' + many2many = fields.Many2One('test.import_data.many2many', 'Many2One') + target = fields.Many2One('test.import_data.many2many.target', 'Target') ImportDataMany2ManyRelation() class ImportDataOne2Many(ModelSQL): "Import Data One2Many" - _name = 'tests.import_data.one2many' + _name = 'test.import_data.one2many' _description = __doc__ name = fields.Char('Name') - one2many = fields.One2Many('tests.import_data.one2many.target', 'one2many', + one2many = fields.One2Many('test.import_data.one2many.target', 'one2many', 'One2Many') ImportDataOne2Many() @@ -158,17 +158,17 @@ ImportDataOne2Many() class ImportDataOne2ManyTarget(ModelSQL): "Import Data One2Many Target" - _name = 'tests.import_data.one2many.target' + _name = 'test.import_data.one2many.target' _description = __doc__ name = fields.Char('Name') - one2many = fields.Many2One('tests.import_data.one2many', 'One2Many') + one2many = fields.Many2One('test.import_data.one2many', 'One2Many') ImportDataOne2ManyTarget() class ImportDataReferenceSelection(ModelSQL): "Import Data Reference Selection" - _name = 'tests.import_data.reference.selection' + _name = 'test.import_data.reference.selection' _description = __doc__ name = fields.Char('Name') @@ -177,9 +177,9 @@ ImportDataReferenceSelection() class ImportDataReference(ModelSQL): "Import Data Reference" - _name = 'tests.import_data.reference' + _name = 'test.import_data.reference' reference = fields.Reference('Reference', [ - ('tests.import_data.reference.selection', 'Test'), + ('test.import_data.reference.selection', 'Test'), ]) ImportDataReference() diff --git a/trytond/tests/import_data.xml b/trytond/test/import_data.xml similarity index 70% rename from trytond/tests/import_data.xml rename to trytond/test/import_data.xml index b76bcab860..c4df503bf1 100644 --- a/trytond/tests/import_data.xml +++ b/trytond/test/import_data.xml @@ -4,57 +4,57 @@ this repository contains the full copyright notices and license terms. --> - Test - Duplicate - Duplicate - Test 1 - Test 2 - Test, comma - Duplicate - Duplicate - Test - Duplicate - Duplicate diff --git a/trytond/tests/model.py b/trytond/test/model.py similarity index 93% rename from trytond/tests/model.py rename to trytond/test/model.py index 2b1a8f126b..e5bd88a101 100644 --- a/trytond/tests/model.py +++ b/trytond/test/model.py @@ -5,7 +5,7 @@ from trytond.model import ModelSingleton, ModelSQL, fields class Singleton(ModelSingleton, ModelSQL): 'Singleton' - _name = 'tests.singleton' + _name = 'test.singleton' _description = __doc__ name = fields.Char('Name') diff --git a/trytond/tests/mptt.py b/trytond/test/mptt.py similarity index 86% rename from trytond/tests/mptt.py rename to trytond/test/mptt.py index 028aada85e..f3a17396ea 100644 --- a/trytond/tests/mptt.py +++ b/trytond/test/mptt.py @@ -6,15 +6,15 @@ from trytond.model import ModelView, ModelSQL, fields class MPTT(ModelSQL, ModelView): 'Modified Preorder Tree Traversal' - _name = 'tests.mptt' + _name = 'test.mptt' _description = __doc__ name = fields.Char('Name', required=True) sequence = fields.Integer('Sequence') - parent = fields.Many2One('tests.mptt', "Parent", select=1, + parent = fields.Many2One('test.mptt', "Parent", select=1, left="left", right="right") left = fields.Integer('Left', required=True, select=1) right = fields.Integer('Right', required=True, select=1) - childs = fields.One2Many('tests.mptt', 'parent', 'Children') + childs = fields.One2Many('test.mptt', 'parent', 'Children') active = fields.Boolean('Active') def __init__(self): diff --git a/trytond/tests/tests.py b/trytond/test/test.py similarity index 87% rename from trytond/tests/tests.py rename to trytond/test/test.py index 6900d9604b..5eac455526 100644 --- a/trytond/tests/tests.py +++ b/trytond/test/test.py @@ -7,7 +7,7 @@ import datetime class Boolean(ModelSQL): 'Boolean' - _name = 'tests.boolean' + _name = 'test.boolean' _description = __doc__ boolean = fields.Boolean(string='Boolean', help='Test boolean', required=False) @@ -17,7 +17,7 @@ Boolean() class BooleanDefault(ModelSQL): 'Boolean Default' - _name = 'tests.boolean_default' + _name = 'test.boolean_default' _description = __doc__ boolean = fields.Boolean(string='Boolean', help='Test boolean', required=False) @@ -30,7 +30,7 @@ BooleanDefault() class Integer(ModelSQL): 'Integer' - _name = 'tests.integer' + _name = 'test.integer' _description = __doc__ integer = fields.Integer(string='Integer', help='Test integer', required=False) @@ -40,7 +40,7 @@ Integer() class IntegerDefault(ModelSQL): 'Integer Default' - _name = 'tests.integer_default' + _name = 'test.integer_default' _description = __doc__ integer = fields.Integer(string='Integer', help='Test integer', required=False) @@ -53,7 +53,7 @@ IntegerDefault() class IntegerRequired(ModelSQL): 'Integer Required' - _name = 'tests.integer_required' + _name = 'test.integer_required' _description = __doc__ integer = fields.Integer(string='Integer', help='Test integer', required=True) @@ -63,7 +63,7 @@ IntegerRequired() class Float(ModelSQL): 'Float' - _name = 'tests.float' + _name = 'test.float' _description = __doc__ float = fields.Float(string='Float', help='Test float', required=False) @@ -73,7 +73,7 @@ Float() class FloatDefault(ModelSQL): 'Float Default' - _name = 'tests.float_default' + _name = 'test.float_default' _description = __doc__ float = fields.Float(string='Float', help='Test float', required=False) @@ -86,7 +86,7 @@ FloatDefault() class FloatRequired(ModelSQL): 'Float Required' - _name = 'tests.float_required' + _name = 'test.float_required' _description = __doc__ float = fields.Float(string='Float', help='Test float', required=True) @@ -96,7 +96,7 @@ FloatRequired() class Numeric(ModelSQL): 'Numeric' - _name = 'tests.numeric' + _name = 'test.numeric' _description = __doc__ numeric = fields.Numeric(string='Numeric', help='Test numeric', required=False) @@ -106,7 +106,7 @@ Numeric() class NumericDefault(ModelSQL): 'Numeric Default' - _name = 'tests.numeric_default' + _name = 'test.numeric_default' _description = __doc__ numeric = fields.Numeric(string='Numeric', help='Test numeric', required=False) @@ -119,7 +119,7 @@ NumericDefault() class NumericRequired(ModelSQL): 'Numeric Required' - _name = 'tests.numeric_required' + _name = 'test.numeric_required' _description = __doc__ numeric = fields.Numeric(string='Numeric', help='Test numeric', required=True) @@ -129,7 +129,7 @@ NumericRequired() class Char(ModelSQL): 'Char' - _name = 'tests.char' + _name = 'test.char' _description = __doc__ char = fields.Char(string='Char', size=None, help='Test char', required=False) @@ -139,7 +139,7 @@ Char() class CharDefault(ModelSQL): 'Char Default' - _name = 'tests.char_default' + _name = 'test.char_default' _description = __doc__ char = fields.Char(string='Char', size=None, help='Test char', required=False) @@ -152,7 +152,7 @@ CharDefault() class CharRequired(ModelSQL): 'Char Required' - _name = 'tests.char_required' + _name = 'test.char_required' _description = __doc__ char = fields.Char(string='Char', size=None, help='Test char', required=True) @@ -162,7 +162,7 @@ CharRequired() class CharSize(ModelSQL): 'Char Size' - _name = 'tests.char_size' + _name = 'test.char_size' _description = __doc__ char = fields.Char(string='Char', size=5, help='Test char', required=False) @@ -172,7 +172,7 @@ CharSize() class Text(ModelSQL): 'Text' - _name = 'tests.text' + _name = 'test.text' _description = __doc__ text = fields.Text(string='Text', size=None, help='Test text', required=False) @@ -182,7 +182,7 @@ Text() class TextDefault(ModelSQL): 'Text Default' - _name = 'tests.text_default' + _name = 'test.text_default' _description = __doc__ text = fields.Text(string='Text', size=None, help='Test text', required=False) @@ -195,7 +195,7 @@ TextDefault() class TextRequired(ModelSQL): 'Text Required' - _name = 'tests.text_required' + _name = 'test.text_required' _description = __doc__ text = fields.Text(string='Text', size=None, help='Test text', required=True) @@ -205,7 +205,7 @@ TextRequired() class TextSize(ModelSQL): 'Text Size' - _name = 'tests.text_size' + _name = 'test.text_size' _description = __doc__ text = fields.Text(string='Text', size=5, help='Test text', required=False) @@ -215,7 +215,7 @@ TextSize() class Sha(ModelSQL): 'Sha' - _name = 'tests.sha' + _name = 'test.sha' _description = __doc__ sha = fields.Sha(string='Sha', help='Test sha', required=False) @@ -225,7 +225,7 @@ Sha() class ShaDefault(ModelSQL): 'Sha Default' - _name = 'tests.sha_default' + _name = 'test.sha_default' _description = __doc__ sha = fields.Sha(string='Sha', help='Test sha', required=False) @@ -238,7 +238,7 @@ ShaDefault() class ShaRequired(ModelSQL): 'Sha Required' - _name = 'tests.sha_required' + _name = 'test.sha_required' _description = __doc__ sha = fields.Sha(string='Sha', help='Test sha', required=True) @@ -248,7 +248,7 @@ ShaRequired() class Date(ModelSQL): 'Date' - _name = 'tests.date' + _name = 'test.date' _description = __doc__ date = fields.Date(string='Date', help='Test date', required=False) @@ -258,7 +258,7 @@ Date() class DateDefault(ModelSQL): 'Date Default' - _name = 'tests.date_default' + _name = 'test.date_default' _description = __doc__ date = fields.Date(string='Date', help='Test date', required=False) @@ -271,7 +271,7 @@ DateDefault() class DateRequired(ModelSQL): 'Date Required' - _name = 'tests.date_required' + _name = 'test.date_required' _description = __doc__ date = fields.Date(string='Date', help='Test date', required=True) @@ -281,7 +281,7 @@ DateRequired() class DateTime(ModelSQL): 'DateTime' - _name = 'tests.datetime' + _name = 'test.datetime' _description = __doc__ datetime = fields.DateTime(string='DateTime', help='Test datetime', required=False) @@ -291,7 +291,7 @@ DateTime() class DateTimeDefault(ModelSQL): 'DateTime Default' - _name = 'tests.datetime_default' + _name = 'test.datetime_default' _description = __doc__ datetime = fields.DateTime(string='DateTime', help='Test datetime', required=False) @@ -304,7 +304,7 @@ DateTimeDefault() class DateTimeRequired(ModelSQL): 'DateTime Required' - _name = 'tests.datetime_required' + _name = 'test.datetime_required' _description = __doc__ datetime = fields.DateTime(string='DateTime', help='Test datetime', required=True) diff --git a/trytond/tests/__init__.py b/trytond/tests/__init__.py index 025503771d..c86640b67f 100644 --- a/trytond/tests/__init__.py +++ b/trytond/tests/__init__.py @@ -1,7 +1,2 @@ #This file is part of Tryton. The COPYRIGHT file at the top level of #this repository contains the full copyright notices and license terms. - -from tests import * -from model import * -from mptt import * -from import_data import * diff --git a/trytond/tests/test_fields.py b/trytond/tests/test_fields.py new file mode 100644 index 0000000000..9b2eac0b5a --- /dev/null +++ b/trytond/tests/test_fields.py @@ -0,0 +1,2053 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import logging +logging.basicConfig(level=logging.FATAL) + +import unittest +import datetime +from decimal import Decimal +from trytond.tests.test_tryton import POOL, DB, USER, CONTEXT, install_module + + +class FieldsTestCase(unittest.TestCase): + ''' + Test Fields. + ''' + + def setUp(self): + install_module('test') + self.boolean = POOL.get('test.boolean') + self.boolean_default = POOL.get('test.boolean_default') + + self.integer = POOL.get('test.integer') + self.integer_default = POOL.get('test.integer_default') + self.integer_required = POOL.get('test.integer_required') + + self.float = POOL.get('test.float') + self.float_default = POOL.get('test.float_default') + self.float_required = POOL.get('test.float_required') + + self.numeric = POOL.get('test.numeric') + self.numeric_default = POOL.get('test.numeric_default') + self.numeric_required = POOL.get('test.numeric_required') + + 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.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.sha = POOL.get('test.sha') + self.sha_default = POOL.get('test.sha_default') + self.sha_required = POOL.get('test.sha_required') + + self.date = POOL.get('test.date') + self.date_default = POOL.get('test.date_default') + self.date_required = POOL.get('test.date_required') + + self.datetime = POOL.get('test.datetime') + self.datetime_default = POOL.get('test.datetime_default') + self.datetime_required = POOL.get('test.datetime_required') + + def test0010boolean(self): + ''' + Test Boolean. + ''' + cursor = DB.cursor() + + boolean1_id = self.boolean.create(cursor, USER, { + 'boolean': True, + }, CONTEXT) + self.assert_(boolean1_id) + + boolean1 = self.boolean.read(cursor, USER, boolean1_id, ['boolean'], + CONTEXT) + self.assert_(boolean1['boolean'] == True) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', '=', True), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == [boolean1_id]) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', '!=', True), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == []) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'in', [True]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == [boolean1_id]) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == []) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'not in', [True]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == []) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == [boolean1_id]) + + boolean2_id = self.boolean.create(cursor, USER, { + 'boolean': False, + }, CONTEXT) + self.assert_(boolean2_id) + + boolean2 = self.boolean.read(cursor, USER, boolean2_id, ['boolean'], + CONTEXT) + self.assert_(boolean2['boolean'] == False) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == [boolean2_id]) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'in', [True, False]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == [boolean1_id, boolean2_id]) + + boolean_ids = self.boolean.search(cursor, USER, [ + ('boolean', 'not in', [True, False]), + ], 0, None, None, CONTEXT) + self.assert_(boolean_ids == []) + + boolean3_id = self.boolean.create(cursor, USER, {}, CONTEXT) + self.assert_(boolean3_id) + + boolean3 = self.boolean.read(cursor, USER, boolean3_id, ['boolean'], + CONTEXT) + self.assert_(boolean3['boolean'] == False) + + boolean4_id = self.boolean_default.create(cursor, USER, {}, CONTEXT) + self.assert_(boolean4_id) + + boolean4 = self.boolean_default.read(cursor, USER, boolean4_id, + ['boolean'], CONTEXT) + self.assert_(boolean4['boolean'] == True) + + self.boolean.write(cursor, USER, boolean1_id, { + 'boolean': False, + }, CONTEXT) + boolean1 = self.boolean.read(cursor, USER, boolean1_id, ['boolean'], + CONTEXT) + self.assert_(boolean1['boolean'] == False) + + self.boolean.write(cursor, USER, boolean2_id, { + 'boolean': True, + }, CONTEXT) + boolean2 = self.boolean.read(cursor, USER, boolean2_id, ['boolean'], + CONTEXT) + self.assert_(boolean2['boolean'] == True) + + cursor.rollback() + cursor.close() + + def test0020integer(self): + ''' + Test Integer. + ''' + cursor = DB.cursor() + + integer1_id = self.integer.create(cursor, USER, { + 'integer': 1, + }, CONTEXT) + self.assert_(integer1_id) + + integer1 = self.integer.read(cursor, USER, integer1_id, ['integer'], + CONTEXT) + self.assert_(integer1['integer'] == 1) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '=', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '=', 0), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '!=', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '!=', 0), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'in', [1]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'in', [0]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'not in', [1]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'not in', [0]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<', 5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<', -5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<=', 5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<=', -5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '<=', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>', 5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>', -5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>=', 5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>=', -5), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '>=', 1), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id]) + + integer2_id = self.integer.create(cursor, USER, { + 'integer': 0, + }, CONTEXT) + self.assert_(integer2_id) + + integer2 = self.integer.read(cursor, USER, integer2_id, ['integer'], + CONTEXT) + self.assert_(integer2['integer'] == 0) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', '=', 0), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer2_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'in', [0, 1]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == [integer1_id, integer2_id]) + + integer_ids = self.integer.search(cursor, USER, [ + ('integer', 'not in', [0, 1]), + ], 0, None, None, CONTEXT) + self.assert_(integer_ids == []) + + integer3_id = self.integer.create(cursor, USER, {}, CONTEXT) + self.assert_(integer3_id) + + integer3 = self.integer.read(cursor, USER, integer3_id, ['integer'], + CONTEXT) + self.assert_(integer3['integer'] == 0) + + integer4_id = self.integer_default.create(cursor, USER, {}, CONTEXT) + self.assert_(integer4_id) + + integer4 = self.integer_default.read(cursor, USER, integer4_id, + ['integer'], CONTEXT) + self.assert_(integer4['integer'] == 5) + + self.integer.write(cursor, USER, integer1_id, { + 'integer': 0, + }, CONTEXT) + integer1 = self.integer.read(cursor, USER, integer1_id, ['integer'], + CONTEXT) + self.assert_(integer1['integer'] == 0) + + self.integer.write(cursor, USER, integer2_id, { + 'integer': 1, + }, CONTEXT) + integer2 = self.integer.read(cursor, USER, integer2_id, ['integer'], + CONTEXT) + self.assert_(integer2['integer'] == 1) + + self.failUnlessRaises(Exception, self.integer.create, cursor, USER, { + 'integer': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.integer.write, cursor, USER, + integer1_id, { + 'integer': 'test', + }, CONTEXT) + + integer5_id = self.integer_required.create(cursor, USER, {}, CONTEXT) + self.assert_(integer5_id) + + integer5 = self.integer_required.read(cursor, USER, integer5_id, + ['integer'], CONTEXT) + self.assert_(integer5['integer'] == 0) + + cursor.rollback() + cursor.close() + + def test0030float(self): + ''' + Test Float. + ''' + cursor = DB.cursor() + + float1_id = self.float.create(cursor, USER, { + 'float': 1.1, + }, CONTEXT) + self.assert_(float1_id) + + float1 = self.float.read(cursor, USER, float1_id, ['float'], CONTEXT) + self.assert_(float1['float'] == 1.1) + + float_ids = self.float.search(cursor, USER, [ + ('float', '=', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '=', 0), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '!=', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '!=', 0), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'in', [1.1]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'in', [0]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'not in', [1.1]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'not in', [0]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<', 5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<', -5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<=', 5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<=', -5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '<=', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>', 5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>', -5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>=', 5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>=', -5), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', '>=', 1.1), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id]) + + float2_id = self.float.create(cursor, USER, { + 'float': 0, + }, CONTEXT) + self.assert_(float2_id) + + float2 = self.float.read(cursor, USER, float2_id, ['float'], CONTEXT) + self.assert_(float2['float'] == 0) + + float_ids = self.float.search(cursor, USER, [ + ('float', '=', 0), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float2_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'in', [0, 1.1]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == [float1_id, float2_id]) + + float_ids = self.float.search(cursor, USER, [ + ('float', 'not in', [0, 1.1]), + ], 0, None, None, CONTEXT) + self.assert_(float_ids == []) + + float3_id = self.float.create(cursor, USER, {}, CONTEXT) + self.assert_(float3_id) + + float3 = self.float.read(cursor, USER, float3_id, ['float'], CONTEXT) + self.assert_(float3['float'] == 0) + + float4_id = self.float_default.create(cursor, USER, {}, CONTEXT) + self.assert_(float4_id) + + float4 = self.float_default.read(cursor, USER, float4_id, ['float'], + CONTEXT) + self.assert_(float4['float'] == 5.5) + + self.float.write(cursor, USER, float1_id, { + 'float': 0, + }, CONTEXT) + float1 = self.float.read(cursor, USER, float1_id, ['float'] , CONTEXT) + self.assert_(float1['float'] == 0) + + self.float.write(cursor, USER, float2_id, { + 'float': 1.1, + }, CONTEXT) + float2 = self.float.read(cursor, USER, float2_id, ['float'], CONTEXT) + self.assert_(float2['float'] == 1.1) + + self.failUnlessRaises(Exception, self.float.create, cursor, USER, { + 'float': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.float.write, float1_id, cursor, + USER, { + 'float': 'test', + }, CONTEXT) + + float5_id = self.float_required.create(cursor, USER, {}, CONTEXT) + self.assert_(float5_id) + + float5 = self.float_required.read(cursor, USER, float5_id, ['float'], + CONTEXT) + self.assert_(float5['float'] == 0) + + def test0040numeric(self): + ''' + Test Numeric. + ''' + cursor = DB.cursor() + + numeric1_id = self.numeric.create(cursor, USER, { + 'numeric': Decimal('1.1'), + }, CONTEXT) + self.assert_(numeric1_id) + + numeric1 = self.numeric.read(cursor, USER, numeric1_id, ['numeric'], + CONTEXT) + self.assert_(numeric1['numeric'] == Decimal('1.1')) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '=', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '=', Decimal('0')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '!=', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '!=', Decimal('0')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'in', [Decimal('1.1')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'in', [Decimal('0')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'not in', [Decimal('1.1')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'not in', [Decimal('0')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<', Decimal('5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<', Decimal('-5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<=', Decimal('5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<=', Decimal('-5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '<=', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>', Decimal('5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>', Decimal('-5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>=', Decimal('5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>=', Decimal('-5')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '>=', Decimal('1.1')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id]) + + numeric2_id = self.numeric.create(cursor, USER, { + 'numeric': Decimal('0'), + }, CONTEXT) + self.assert_(numeric2_id) + + numeric2 = self.numeric.read(cursor, USER, numeric2_id, ['numeric'], + CONTEXT) + self.assert_(numeric2['numeric'] == Decimal('0')) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', '=', Decimal('0')), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric2_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'in', [Decimal('0'), Decimal('1.1')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == [numeric1_id, numeric2_id]) + + numeric_ids = self.numeric.search(cursor, USER, [ + ('numeric', 'not in', [Decimal('0'), Decimal('1.1')]), + ], 0, None, None, CONTEXT) + self.assert_(numeric_ids == []) + + numeric3_id = self.numeric.create(cursor, USER, {}, CONTEXT) + self.assert_(numeric3_id) + + numeric3 = self.numeric.read(cursor, USER, numeric3_id, ['numeric'], + CONTEXT) + self.assert_(numeric3['numeric'] == Decimal('0')) + + numeric4_id = self.numeric_default.create(cursor, USER, {}, CONTEXT) + self.assert_(numeric4_id) + + numeric4 = self.numeric_default.read(cursor, USER, numeric4_id, + ['numeric'], CONTEXT) + self.assert_(numeric4['numeric'] == Decimal('5.5')) + + self.numeric.write(cursor, USER, numeric1_id, { + 'numeric': Decimal('0'), + }, CONTEXT) + numeric1 = self.numeric.read(cursor, USER, numeric1_id, ['numeric'] , + CONTEXT) + self.assert_(numeric1['numeric'] == Decimal('0')) + + self.numeric.write(cursor, USER, numeric2_id, { + 'numeric': Decimal('1.1'), + }, CONTEXT) + numeric2 = self.numeric.read(cursor, USER, numeric2_id, ['numeric'], + CONTEXT) + self.assert_(numeric2['numeric'] == Decimal('1.1')) + + self.failUnlessRaises(Exception, self.numeric.create, cursor, USER, { + 'numeric': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.numeric.write, numeric1_id, + cursor, USER, { + 'numeric': 'test', + }, CONTEXT) + + numeric5_id = self.numeric_required.create(cursor, USER, {}, CONTEXT) + self.assert_(numeric5_id) + + numeric5 = self.numeric_required.read(cursor, USER, numeric5_id, + ['numeric'], CONTEXT) + self.assert_(numeric5['numeric'] == Decimal('0')) + + cursor.rollback() + cursor.close() + + def test0050char(self): + ''' + Test Char. + ''' + cursor = DB.cursor() + + char1_id = self.char.create(cursor, USER, { + 'char': 'Test', + }, CONTEXT) + self.assert_(char1_id) + + char1 = self.char.read(cursor, USER, char1_id, ['char'], CONTEXT) + self.assert_(char1['char'] == 'Test') + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', '!=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', '!=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', '!=', False), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'like', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'like', 'T%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'ilike', 'test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'ilike', 't%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not like', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not like', 'T%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not ilike', 'test'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not ilike', 't%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id]) + + char2_id = self.char.create(cursor, USER, { + 'char': False, + }, CONTEXT) + self.assert_(char2_id) + + char2 = self.char.read(cursor, USER, char2_id, ['char'], CONTEXT) + self.assert_(char2['char'] == None) + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char2_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char1_id, char2_id]) + + char_ids = self.char.search(cursor, USER, [ + ('char', 'not in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == []) + + char3_id = self.char.create(cursor, USER, {}, CONTEXT) + self.assert_(char3_id) + + char3 = self.char.read(cursor, USER, char3_id, ['char'], CONTEXT) + self.assert_(char3['char'] == None) + + char4_id = self.char_default.create(cursor, USER, {}, CONTEXT) + self.assert_(char4_id) + + char4 = self.char_default.read(cursor, USER, char4_id, ['char'], + CONTEXT) + self.assert_(char4['char'] == 'Test') + + self.char.write(cursor, USER, char1_id, { + 'char': False, + }, CONTEXT) + char1 = self.char.read(cursor, USER, char1_id, ['char'], CONTEXT) + self.assert_(char1['char'] == None) + + self.char.write(cursor, USER, char2_id, { + 'char': 'Test', + }, CONTEXT) + char2 = self.char.read(cursor, USER, char2_id, ['char'], CONTEXT) + self.assert_(char2['char'] == 'Test') + + self.failUnlessRaises(Exception, self.char_required.create, cursor, + USER, {}, CONTEXT) + + char5_id = self.char_required.create(cursor, USER, { + 'char': 'Test', + }, CONTEXT) + self.assert_(char5_id) + + char6_id = self.char_size.create(cursor, USER, { + 'char': 'Test', + }, CONTEXT) + self.assert_(char6_id) + + self.failUnlessRaises(Exception, self.char_size.create, cursor, USER, { + 'char': 'foobar', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.char_size.write, cursor, USER, + char6_id, { + 'char': 'foobar', + }, CONTEXT) + + char7_id = self.char.create(cursor, USER, { + 'char': u'é', + }, CONTEXT) + self.assert_(char7_id) + + char7 = self.char.read(cursor, USER, char7_id, ['char'], CONTEXT) + self.assert_(char7['char'] == u'é') + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', u'é'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char7_id]) + + self.char.write(cursor, USER, char7_id, { + 'char': 'é', + }, CONTEXT) + char7 = self.char.read(cursor, USER, char7_id, ['char'], CONTEXT) + self.assert_(char7['char'] == u'é') + + char_ids = self.char.search(cursor, USER, [ + ('char', '=', 'é'), + ], 0, None, None, CONTEXT) + self.assert_(char_ids == [char7_id]) + + cursor.rollback() + cursor.close() + + def test0060text(self): + ''' + Test Text. + ''' + cursor = DB.cursor() + + text1_id = self.text.create(cursor, USER, { + 'text': 'Test', + }, CONTEXT) + self.assert_(text1_id) + + text1 = self.text.read(cursor, USER, text1_id, ['text'], CONTEXT) + self.assert_(text1['text'] == 'Test') + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', '!=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', '!=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', '!=', False), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'like', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'like', 'T%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'ilike', 'test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'ilike', 't%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not like', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not like', 'T%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not ilike', 'test'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not ilike', 't%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id]) + + text2_id = self.text.create(cursor, USER, { + 'text': False, + }, CONTEXT) + self.assert_(text2_id) + + text2 = self.text.read(cursor, USER, text2_id, ['text'], CONTEXT) + self.assert_(text2['text'] == None) + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text2_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text1_id, text2_id]) + + text_ids = self.text.search(cursor, USER, [ + ('text', 'not in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == []) + + text3_id = self.text.create(cursor, USER, {}, CONTEXT) + self.assert_(text3_id) + + text3 = self.text.read(cursor, USER, text3_id, ['text'], CONTEXT) + self.assert_(text3['text'] == None) + + text4_id = self.text_default.create(cursor, USER, {}, CONTEXT) + self.assert_(text4_id) + + text4 = self.text_default.read(cursor, USER, text4_id, ['text'], + CONTEXT) + self.assert_(text4['text'] == 'Test') + + self.text.write(cursor, USER, text1_id, { + 'text': False, + }, CONTEXT) + text1 = self.text.read(cursor, USER, text1_id, ['text'], CONTEXT) + self.assert_(text1['text'] == None) + + self.text.write(cursor, USER, text2_id, { + 'text': 'Test', + }, CONTEXT) + text2 = self.text.read(cursor, USER, text2_id, ['text'], CONTEXT) + self.assert_(text2['text'] == 'Test') + + self.failUnlessRaises(Exception, self.text_required.create, cursor, + USER, {}, CONTEXT) + + text5_id = self.text_required.create(cursor, USER, { + 'text': 'Test', + }, CONTEXT) + self.assert_(text5_id) + + text6_id = self.text_size.create(cursor, USER, { + 'text': 'Test', + }, CONTEXT) + self.assert_(text6_id) + + self.failUnlessRaises(Exception, self.text_size.create, cursor, USER, { + 'text': 'foobar', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.text_size.write, cursor, USER, + text6_id, { + 'text': 'foobar', + }, CONTEXT) + + text7_id = self.text.create(cursor, USER, { + 'text': 'Foo\nBar', + }, CONTEXT) + self.assert_(text7_id) + + text8_id = self.text.create(cursor, USER, { + 'text': u'é', + }, CONTEXT) + self.assert_(text8_id) + + text8 = self.text.read(cursor, USER, text8_id, ['text'], CONTEXT) + self.assert_(text8['text'] == u'é') + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', u'é'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text8_id]) + + self.text.write(cursor, USER, text8_id, { + 'text': 'é', + }, CONTEXT) + text8 = self.text.read(cursor, USER, text8_id, ['text'], CONTEXT) + self.assert_(text8['text'] == u'é') + + text_ids = self.text.search(cursor, USER, [ + ('text', '=', 'é'), + ], 0, None, None, CONTEXT) + self.assert_(text_ids == [text8_id]) + + cursor.rollback() + cursor.close() + + def test0070sha(self): + ''' + Test Sha. + ''' + cursor = DB.cursor() + + sha1_id = self.sha.create(cursor, USER, { + 'sha': 'Test', + }, CONTEXT) + self.assert_(sha1_id) + + sha1 = self.sha.read(cursor, USER, sha1_id, ['sha'], CONTEXT) + self.assert_(sha1['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '!=', 'Test'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '!=', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '!=', False), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not in', ['Test']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not in', ['Foo']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'like', '640a%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'ilike', '640A%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not like', '640a%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not like', 'Foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not like', 'F%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not ilike', '640A%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not ilike', 'foo'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not ilike', 'f%'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id]) + + sha2_id = self.sha.create(cursor, USER, { + 'sha': False, + }, CONTEXT) + self.assert_(sha2_id) + + sha2 = self.sha.read(cursor, USER, sha2_id, ['sha'], CONTEXT) + self.assert_(sha2['sha'] == None) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha2_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha1_id, sha2_id]) + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', 'not in', [False, 'Test']), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == []) + + sha3_id = self.sha.create(cursor, USER, {}, CONTEXT) + self.assert_(sha3_id) + + sha3 = self.sha.read(cursor, USER, sha3_id, ['sha'], CONTEXT) + self.assert_(sha3['sha'] == None) + + sha4_id = self.sha_default.create(cursor, USER, {}, CONTEXT) + self.assert_(sha4_id) + + sha4 = self.sha_default.read(cursor, USER, sha4_id, ['sha'], CONTEXT) + self.assert_(sha4['sha'] == 'ba79baeb9f10896a46ae74715271b7f586e74640') + + self.sha.write(cursor, USER, sha1_id, { + 'sha': False, + }, CONTEXT) + sha1 = self.sha.read(cursor, USER, sha1_id, ['sha'], CONTEXT) + self.assert_(sha1['sha'] == None) + + self.sha.write(cursor, USER, sha2_id, { + 'sha': 'Test', + }, CONTEXT) + sha2 = self.sha.read(cursor, USER, sha2_id, ['sha'], CONTEXT) + self.assert_(sha2['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') + + self.failUnlessRaises(Exception, self.sha_required.create, cursor, + USER, {}, CONTEXT) + + sha5_id = self.sha_required.create(cursor, USER, { + 'sha': 'Test', + }, CONTEXT) + self.assert_(sha5_id) + + sha6_id = self.sha.create(cursor, USER, { + 'sha': u'é', + }, CONTEXT) + self.assert_(sha6_id) + + sha6 = self.sha.read(cursor, USER, sha6_id, ['sha'], CONTEXT) + self.assert_(sha6['sha'] == + u'bf15be717ac1b080b4f1c456692825891ff5073d') + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', u'é'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha6_id]) + + self.sha.write(cursor, USER, sha6_id, { + 'sha': 'é', + }, CONTEXT) + sha6 = self.sha.read(cursor, USER, sha6_id, ['sha'], CONTEXT) + self.assert_(sha6['sha'] == + u'bf15be717ac1b080b4f1c456692825891ff5073d') + + sha_ids = self.sha.search(cursor, USER, [ + ('sha', '=', 'é'), + ], 0, None, None, CONTEXT) + self.assert_(sha_ids == [sha6_id]) + + cursor.rollback() + cursor.close() + + def test0080date(self): + ''' + Test Date. + ''' + cursor = DB.cursor() + + today = datetime.date(2009, 1, 1) + tomorrow = today + datetime.timedelta(1) + yesterday = today - datetime.timedelta(1) + default_date = datetime.date(2000, 1, 1) + + date1_id = self.date.create(cursor, USER, { + 'date': today, + }, CONTEXT) + self.assert_(date1_id) + + date1 = self.date.read(cursor, USER, date1_id, ['date'], CONTEXT) + self.assert_(date1['date'] == today) + + date_ids = self.date.search(cursor, USER, [ + ('date', '=', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '!=', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '!=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '!=', False), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'in', [today]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'in', [tomorrow]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'not in', [today]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'not in', [tomorrow]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<=', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '<=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', '>=', today), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id]) + + date2_id = self.date.create(cursor, USER, { + 'date': yesterday, + }, CONTEXT) + self.assert_(date2_id) + + date2 = self.date.read(cursor, USER, date2_id, ['date'], CONTEXT) + self.assert_(date2['date'] == yesterday) + + date_ids = self.date.search(cursor, USER, [ + ('date', '=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date2_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'in', [yesterday, today]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == [date1_id, date2_id]) + + date_ids = self.date.search(cursor, USER, [ + ('date', 'not in', [yesterday, today]), + ], 0, None, None, CONTEXT) + self.assert_(date_ids == []) + + date3_id = self.date.create(cursor, USER, {}, CONTEXT) + self.assert_(date3_id) + + date3 = self.date.read(cursor, USER, date3_id, ['date'], CONTEXT) + self.assert_(date3['date'] == None) + + date4_id = self.date_default.create(cursor, USER, {}, CONTEXT) + self.assert_(date4_id) + + date4 = self.date_default.read(cursor, USER, date4_id, ['date'], + CONTEXT) + self.assert_(date4['date'] == default_date) + + self.date.write(cursor, USER, date1_id, { + 'date': yesterday, + }, CONTEXT) + date1 = self.date.read(cursor, USER, date1_id, ['date'], CONTEXT) + self.assert_(date1['date'] == yesterday) + + self.date.write(cursor, USER, date2_id, { + 'date': today, + }, CONTEXT) + date2 = self.date.read(cursor, USER, date2_id, ['date'], CONTEXT) + self.assert_(date2['date'] == today) + + self.failUnlessRaises(Exception, self.date.create, cursor, USER, { + 'date': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.write, cursor, USER, + date1_id, { + 'date': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.create, cursor, USER, { + 'date': 1, + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.write, cursor, USER, + date1_id, { + 'date': 1, + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.create, cursor, USER, { + 'date': datetime.datetime.now(), + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.write, cursor, USER, + date1_id, { + 'date': datetime.datetime.now(), + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.create, cursor, USER, { + 'date': '2009-13-01', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.date.write, cursor, USER, + date1_id, { + 'date': '2009-02-29', + }, CONTEXT) + + date5_id = self.date.create(cursor, USER, { + 'date': '2009-01-01', + }, CONTEXT) + self.assert_(date5_id) + date5 = self.date.read(cursor, USER, date5_id, ['date'], CONTEXT) + self.assert_(date5['date'] == datetime.date(2009, 1, 1)) + + self.failUnlessRaises(Exception, self.date_required.create, cursor, + USER, {}, CONTEXT) + + date6_id = self.date_required.create(cursor, USER, { + 'date': today, + }, CONTEXT) + self.assert_(date6_id) + + date7_id = self.date.create(cursor, USER, { + 'date': None, + }, CONTEXT) + self.assert_(date7_id) + + date8_id = self.date.create(cursor, USER, { + 'date': False, + }, CONTEXT) + self.assert_(date8_id) + + cursor.rollback() + cursor.close() + + def test0090datetime(self): + ''' + Test DateTime. + ''' + cursor = DB.cursor() + + 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_id = self.datetime.create(cursor, USER, { + 'datetime': today, + }, CONTEXT) + self.assert_(datetime1_id) + + datetime1 = self.datetime.read(cursor, USER, datetime1_id, + ['datetime'], CONTEXT) + self.assert_(datetime1['datetime'] == today) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '=', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '=', False), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '!=', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '!=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '!=', False), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'in', [today]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'in', [tomorrow]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'in', []), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'not in', [today]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'not in', [tomorrow]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'not in', [False]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'not in', []), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<=', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '<=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>=', tomorrow), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '>=', today), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id]) + + datetime2_id = self.datetime.create(cursor, USER, { + 'datetime': yesterday, + }, CONTEXT) + self.assert_(datetime2_id) + + datetime2 = self.datetime.read(cursor, USER, datetime2_id, + ['datetime'], CONTEXT) + self.assert_(datetime2['datetime'] == yesterday) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', '=', yesterday), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime2_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'in', [yesterday, today]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == [datetime1_id, datetime2_id]) + + datetime_ids = self.datetime.search(cursor, USER, [ + ('datetime', 'not in', [yesterday, today]), + ], 0, None, None, CONTEXT) + self.assert_(datetime_ids == []) + + datetime3_id = self.datetime.create(cursor, USER, {}, CONTEXT) + self.assert_(datetime3_id) + + datetime3 = self.datetime.read(cursor, USER, datetime3_id, + ['datetime'], CONTEXT) + self.assert_(datetime3['datetime'] == None) + + datetime4_id = self.datetime_default.create(cursor, USER, {}, CONTEXT) + self.assert_(datetime4_id) + + datetime4 = self.datetime_default.read(cursor, USER, datetime4_id, + ['datetime'], CONTEXT) + self.assert_(datetime4['datetime'] == default_datetime) + + self.datetime.write(cursor, USER, datetime1_id, { + 'datetime': yesterday, + }, CONTEXT) + datetime1 = self.datetime.read(cursor, USER, datetime1_id, + ['datetime'], CONTEXT) + self.assert_(datetime1['datetime'] == yesterday) + + self.datetime.write(cursor, USER, datetime2_id, { + 'datetime': today, + }, CONTEXT) + datetime2 = self.datetime.read(cursor, USER, datetime2_id, + ['datetime'], CONTEXT) + self.assert_(datetime2['datetime'] == today) + + self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { + 'datetime': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, + datetime1_id, { + 'datetime': 'test', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { + 'datetime': 1, + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, + datetime1_id, { + 'datetime': 1, + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { + 'datetime': datetime.date.today(), + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, + datetime1_id, { + 'datetime': datetime.date.today(), + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.create, cursor, USER, { + 'datetime': '2009-13-01 12:30:00', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, + datetime1_id, { + 'datetime': '2009-02-29 12:30:00', + }, CONTEXT) + + self.failUnlessRaises(Exception, self.datetime.write, cursor, USER, + datetime1_id, { + 'datetime': '2009-01-01 25:00:00', + }, CONTEXT) + + datetime5_id = self.datetime.create(cursor, USER, { + 'datetime': '2009-01-01 12:00:00', + }, CONTEXT) + self.assert_(datetime5_id) + datetime5 = self.datetime.read(cursor, USER, datetime5_id, + ['datetime'], CONTEXT) + self.assert_(datetime5['datetime'] == datetime.datetime(2009, 1, 1, 12, + 0, 0)) + + self.failUnlessRaises(Exception, self.datetime_required.create, cursor, + USER, {}, CONTEXT) + + datetime6_id = self.datetime_required.create(cursor, USER, { + 'datetime': today, + }, CONTEXT) + self.assert_(datetime6_id) + + datetime7_id = self.datetime.create(cursor, USER, { + 'datetime': None, + }, CONTEXT) + self.assert_(datetime7_id) + + datetime8_id = self.datetime.create(cursor, USER, { + 'datetime': False, + }, CONTEXT) + self.assert_(datetime8_id) + + cursor.rollback() + cursor.close() + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/trytond/tests/test_importdata.py b/trytond/tests/test_importdata.py new file mode 100644 index 0000000000..786b59d799 --- /dev/null +++ b/trytond/tests/test_importdata.py @@ -0,0 +1,415 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import logging +logging.basicConfig(level=logging.FATAL) + +import unittest +from trytond.tests.test_tryton import POOL, DB, USER, CONTEXT, install_module + + +class ImportDataTestCase(unittest.TestCase): + ''' + Test import_data. + ''' + + def setUp(self): + install_module('test') + self.boolean = POOL.get('test.import_data.boolean') + self.integer = POOL.get('test.import_data.integer') + self.float = POOL.get('test.import_data.float') + self.numeric = POOL.get('test.import_data.numeric') + self.char = POOL.get('test.import_data.char') + self.text = POOL.get('test.import_data.text') + self.sha = POOL.get('test.import_data.sha') + self.date = POOL.get('test.import_data.date') + self.datetime = POOL.get('test.import_data.datetime') + self.selection = POOL.get('test.import_data.selection') + self.many2one = POOL.get('test.import_data.many2one') + self.many2many = POOL.get('test.import_data.many2many') + self.one2many = POOL.get('test.import_data.one2many') + self.reference = POOL.get('test.import_data.reference') + + def test0010boolean(self): + ''' + Test boolean. + ''' + cursor = DB.cursor() + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['True']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['False']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['0']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['True'], ['False']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.boolean.import_data(cursor, USER, ['boolean'], + [['foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0020integer(self): + ''' + Test integer. + ''' + cursor = DB.cursor() + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['-1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['1'], ['2']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['1.1']], CONTEXT)[0] == -1) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['-1.1']], CONTEXT)[0] == -1) + + self.assert_(self.integer.import_data(cursor, USER, ['integer'], + [['foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0030float(self): + ''' + Test float. + ''' + cursor = DB.cursor() + + self.assert_(self.float.import_data(cursor, USER, ['float'], [['1.1']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.float.import_data(cursor, USER, ['float'], + [['-1.1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.float.import_data(cursor, USER, ['float'], [['1']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.float.import_data(cursor, USER, ['float'], [['']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.float.import_data(cursor, USER, ['float'], [['1.1'], + ['2.2']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.float.import_data(cursor, USER, ['float'], [['foo']], + CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0040numeric(self): + ''' + Test numeric. + ''' + cursor = DB.cursor() + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['1.1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['-1.1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['1.1'], ['2.2']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.numeric.import_data(cursor, USER, ['numeric'], + [['foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0050char(self): + ''' + Test char. + ''' + cursor = DB.cursor() + + self.assert_(self.char.import_data(cursor, USER, ['char'], [['test']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.char.import_data(cursor, USER, ['char'], [['']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.char.import_data(cursor, USER, ['char'], [['test'], + ['foo'], ['bar']], CONTEXT) == (3, 0, 0, 0)) + + cursor.rollback() + cursor.close() + + def test0060text(self): + ''' + Test text. + ''' + cursor = DB.cursor() + + self.assert_(self.text.import_data(cursor, USER, ['text'], [['test']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.text.import_data(cursor, USER, ['text'], [['']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.text.import_data(cursor, USER, ['text'], [['test'], + ['foo'], ['bar']], CONTEXT) == (3, 0, 0, 0)) + + cursor.rollback() + cursor.close() + + def test0070sha(self): + ''' + Test sha. + ''' + cursor = DB.cursor() + + self.assert_(self.sha.import_data(cursor, USER, ['sha'], [['test']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.sha.import_data(cursor, USER, ['sha'], [['']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.sha.import_data(cursor, USER, ['sha'], [['test'], + ['foo']], CONTEXT) == (2, 0, 0, 0)) + + cursor.rollback() + cursor.close() + + def test0080date(self): + ''' + Test date. + ''' + cursor = DB.cursor() + + self.assert_(self.date.import_data(cursor, USER, ['date'], + [['2010-01-01']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.date.import_data(cursor, USER, ['date'], [['']], + CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.date.import_data(cursor, USER, ['date'], [ + ['2010-01-01'], ['2010-02-01']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.date.import_data(cursor, USER, ['date'], [['foo']], + CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0090datetime(self): + ''' + Test datetime. + ''' + cursor = DB.cursor() + + self.assert_(self.datetime.import_data(cursor, USER, ['datetime'], + [['2010-01-01 12:00:00']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.datetime.import_data(cursor, USER, ['datetime'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.datetime.import_data(cursor, USER, ['datetime'], + [['2010-01-01 12:00:00'], ['2010-01-01 13:30:00']], CONTEXT) == (2, + 0, 0, 0)) + + self.assert_(self.datetime.import_data(cursor, USER, ['datetime'], + [['foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0100selection(self): + ''' + Test selection. + ''' + cursor = DB.cursor() + + self.assert_(self.selection.import_data(cursor, USER, ['selection'], + [['select1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.selection.import_data(cursor, USER, ['selection'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.selection.import_data(cursor, USER, ['selection'], + [['select1'], ['select2']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.selection.import_data(cursor, USER, ['selection'], + [['foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0110many2one(self): + ''' + Test many2one. + ''' + cursor = DB.cursor() + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one'], + [['Test']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one:id'], + [['test.import_data_many2one_target_test']], CONTEXT) == (1, 0, 0, + 0)) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one'], + [['Test'], ['Test']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one'], + [['foo']], CONTEXT)[0] == -1) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one'], + [['Duplicate']], CONTEXT)[0] == -1) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one:id'], + [['foo']], CONTEXT)[0] == -1) + + self.assert_(self.many2one.import_data(cursor, USER, ['many2one:id'], + [['test.foo']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0120many2many(self): + ''' + Test many2many. + ''' + cursor = DB.cursor() + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test 1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many:id'], + [['test.import_data_many2many_target_test1']], CONTEXT) == (1, 0, + 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test 1,Test 2']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many:id'], + [['test.import_data_many2many_target_test1,' \ + 'test.import_data_many2many_target_test2']], CONTEXT) == + (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test\, comma']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test\, comma,Test 1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test 1'], ['Test 2']], CONTEXT) == (2, 0, 0, 0)) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['foo']], CONTEXT)[0] == -1) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test 1,foo']], CONTEXT)[0] == -1) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Duplicate']], CONTEXT)[0] == -1) + + self.assert_(self.many2many.import_data(cursor, USER, ['many2many'], + [['Test 1,Duplicate']], CONTEXT)[0] == -1) + + cursor.rollback() + cursor.close() + + def test0130one2many(self): + ''' + Test one2many. + ''' + cursor = DB.cursor() + + self.assert_(self.one2many.import_data(cursor, USER, ['name', + 'one2many/name'], [['Test', 'Test 1']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.one2many.import_data(cursor, USER, ['name', + 'one2many/name'], [['Test', 'Test 1'], ['', 'Test 2']], CONTEXT) == + (1, 0, 0, 0)) + + self.assert_(self.one2many.import_data(cursor, USER, ['name', + 'one2many/name'], [['Test 1', 'Test 1'], ['', 'Test 2'], ['Test 2', + 'Test 1']], CONTEXT) == (2, 0, 0, 0)) + + cursor.rollback() + cursor.close() + + def test0140reference(self): + ''' + Test reference. + ''' + cursor = DB.cursor() + + self.assert_(self.reference.import_data(cursor, USER, ['reference'], + [['test.import_data.reference.selection,Test']], CONTEXT) == (1, 0, + 0, 0)) + + self.assert_(self.reference.import_data(cursor, USER, ['reference:id'], + [['test.import_data.reference.selection,'\ + 'test.import_data_reference_selection_test']], CONTEXT) == + (1, 0, 0, 0)) + + self.assert_(self.reference.import_data(cursor, USER, ['reference'], + [['']], CONTEXT) == (1, 0, 0, 0)) + + self.assert_(self.reference.import_data(cursor, USER, ['reference'], + [['test.import_data.reference.selection,Test'], + ['test.import_data.reference.selection,Test']], CONTEXT) == (2, + 0, 0, 0)) + + self.assert_(self.reference.import_data(cursor, USER, ['reference'], + [['test.import_data.reference.selection,foo']], CONTEXT)[0] == -1) + + self.assert_(self.reference.import_data(cursor, USER, ['reference'], + [['test.import_data.reference.selection,Duplicate']], CONTEXT)[0] + == -1) + + self.assert_(self.reference.import_data(cursor, USER, ['reference:id'], + [['test.import_data.reference.selection,foo']], CONTEXT)[0] == -1) + + self.assert_(self.reference.import_data(cursor, USER, ['reference:id'], + [['test.import_data.reference.selection,test.foo']], CONTEXT)[0] == + -1) + + cursor.rollback() + cursor.close() + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(ImportDataTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) + diff --git a/trytond/tests/test_modelsingleton.py b/trytond/tests/test_modelsingleton.py new file mode 100644 index 0000000000..535262bbcc --- /dev/null +++ b/trytond/tests/test_modelsingleton.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import logging +logging.basicConfig(level=logging.FATAL) + +import unittest +from trytond.tests.test_tryton import POOL, DB, USER, CONTEXT, install_module + + +class ModelSingletonTestCase(unittest.TestCase): + ''' + Test ModelSingleton + ''' + + def setUp(self): + install_module('test') + self.singleton = POOL.get('test.singleton') + + def test0010read(self): + ''' + Test read method. + ''' + cursor = DB.cursor() + + singleton = self.singleton.read(cursor, USER, 1, ['name'], CONTEXT) + self.assert_(singleton['name'] == 'test') + self.assert_(singleton['id'] == 1) + + singleton = self.singleton.read(cursor, USER, [1], ['name'], CONTEXT)[0] + self.assert_(singleton['name'] == 'test') + self.assert_(singleton['id'] == 1) + + cursor.rollback() + cursor.close() + + def test0020create(self): + ''' + Test create method. + ''' + cursor = DB.cursor() + + singleton_id = self.singleton.create(cursor, USER, {'name': 'bar'}, + CONTEXT) + self.assert_(singleton_id) + + singleton = self.singleton.read(cursor, USER, singleton_id, ['name'], + CONTEXT) + self.assert_(singleton['name'] == 'bar') + + singleton2_id = self.singleton.create(cursor, USER, {'name': 'foo'}, + CONTEXT) + self.assert_(singleton2_id == singleton_id) + + singleton = self.singleton.read(cursor, USER, singleton_id, ['name'], + CONTEXT) + self.assert_(singleton['name'] == 'foo') + + singleton_ids = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT) + self.assert_(len(singleton_ids) == 1) + + cursor.rollback() + cursor.close() + + def test0030copy(self): + ''' + Test copy method. + ''' + cursor = DB.cursor() + + singleton_id = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT)[0] + + singleton2_id = self.singleton.copy(cursor, USER, singleton_id, None, + CONTEXT) + self.assert_(singleton2_id == singleton_id) + + singleton_ids = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT) + self.assert_(len(singleton_ids) == 1) + + singleton3_id = self.singleton.copy(cursor, USER, singleton_id, + {'name': 'bar'}, CONTEXT) + self.assert_(singleton3_id == singleton_id) + + singleton_ids = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT) + self.assert_(len(singleton_ids) == 1) + + cursor.rollback() + cursor.close() + + def test0040default_get(self): + ''' + Test default_get method. + ''' + cursor = DB.cursor() + + default = self.singleton.default_get(cursor, USER, ['name'], CONTEXT) + self.assert_(default == {'name': 'test'}) + + default = self.singleton.default_get(cursor, USER, ['create_uid'], + CONTEXT) + self.assert_(len(default) == 2) + + default = self.singleton.default_get(cursor, USER, ['create_uid'], + CONTEXT, False) + self.assert_(len(default) == 1) + + self.singleton.create(cursor, USER, {'name': 'bar'}, CONTEXT) + + default = self.singleton.default_get(cursor, USER, ['name'], CONTEXT) + self.assert_(default == {'name': 'bar'}) + + default = self.singleton.default_get(cursor, USER, ['create_uid'], + CONTEXT) + self.assert_(len(default) == 2) + + default = self.singleton.default_get(cursor, USER, ['create_uid'], + CONTEXT, False) + self.assert_(len(default) == 1) + + cursor.rollback() + cursor.close() + + def test0050search(self): + ''' + Test search method. + ''' + cursor = DB.cursor() + + singleton_ids = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT) + self.assert_(singleton_ids == [1]) + + singleton_ids = self.singleton.search(cursor, USER, [], 0, 1, None, + CONTEXT) + self.assert_(singleton_ids == [1]) + + singleton_ids = self.singleton.search(cursor, USER, [], 0, None, None, + CONTEXT, True) + self.assert_(singleton_ids == 1) + + cursor.rollback() + cursor.close() + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(ModelSingletonTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/trytond/tests/test_mptt.py b/trytond/tests/test_mptt.py new file mode 100644 index 0000000000..a8dcda5927 --- /dev/null +++ b/trytond/tests/test_mptt.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import logging +logging.basicConfig(level=logging.FATAL) + +import unittest +from trytond.tests.test_tryton import POOL, DB, USER, CONTEXT, install_module + + +class MPTTTestCase(unittest.TestCase): + ''' + Test Modified Preorder Tree Traversal. + ''' + + def setUp(self): + install_module('test') + self.mptt = POOL.get('test.mptt') + + def CheckTree(self, cursor, parent_id=False, left=0, right=0): + child_ids = self.mptt.search(cursor, USER, [ + ('parent', '=', parent_id), + ], 0, None, None, CONTEXT) + childs = self.mptt.read(cursor, USER, child_ids, ['left', 'right'], + CONTEXT) + childs.sort(lambda x, y: cmp(child_ids.index(x['id']), + child_ids.index(y['id']))) + for child in childs: + assert child['left'] > left, \ + 'Record (%d): left %d <= parent left %d' % \ + (child['id'], child['left'], left) + assert child['left'] < child['right'], \ + 'Record (%d): left %d >= right %d' % \ + (child['id'], child['left'], child['right']) + assert right == 0 or child['right'] < right, \ + 'Record (%d): right %d >= parent right %d' % \ + (child['id'], child['right'], right) + self.CheckTree(cursor, child['id'], left=child['left'], + right=child['right']) + next_left = 0 + for child in childs: + assert child['left'] > next_left, \ + 'Record (%d): left %d <= next left %d' % \ + (child['id'], child['left'], next_left) + next_left = child['right'] + childs.reverse() + previous_right = 0 + for child in childs: + assert previous_right == 0 or child['right'] < previous_right, \ + 'Record (%d): right %d >= previous right %d' % \ + (child['id'] , child['right'], previous_right) + previous_right = child['left'] + + + def ReParent(self, cursor, parent_id=False): + record_ids = self.mptt.search(cursor, USER, [ + ('parent', '=', parent_id), + ], 0, None, None, CONTEXT) + if not record_ids: + return + for record_id in record_ids: + for record2_id in record_ids: + if record_id != record2_id: + self.mptt.write(cursor, USER, record_id, { + 'parent': record2_id, + }, CONTEXT) + self.mptt.write(cursor, USER, record_id, { + 'parent': parent_id, + }, CONTEXT) + for record_id in record_ids: + self.ReParent(cursor, record_id) + + def ReOrder(self, cursor, parent_id=False): + record_ids = self.mptt.search(cursor, USER, [ + ('parent', '=', parent_id), + ], 0, None, None, CONTEXT) + if not record_ids: + return + i = len(record_ids) + for record_id in record_ids: + self.mptt.write(cursor, USER, record_id, { + 'sequence': i, + }, CONTEXT) + i -= 1 + i = 0 + for record_id in record_ids: + self.mptt.write(cursor, USER, record_id, { + 'sequence': i, + }, CONTEXT) + i += 1 + for record_id in record_ids: + self.ReOrder(cursor, record_id) + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + self.mptt.write(cursor, USER, record_ids, { + 'sequence': 0, + }, CONTEXT) + + def test0010create(self): + ''' + Create tree. + ''' + cursor = DB.cursor() + + new_records = [False] + for j in range(3): + parent_records = new_records + new_records = [] + k = 0 + for parent_record in parent_records: + for i in range(3): + record_id = self.mptt.create(cursor, USER, { + 'name': 'Test %d %d %d' % (j, k, i), + 'parent': parent_record, + }, CONTEXT) + new_records.append(record_id) + k += 1 + self.CheckTree(cursor) + + cursor.commit() + cursor.close() + + def test0020reorder(self): + ''' + Re-order. + ''' + cursor = DB.cursor() + + self.ReOrder(cursor) + + cursor.rollback() + cursor.close() + + def test0030reparent(self): + ''' + Re-parent. + ''' + cursor = DB.cursor() + + self.ReParent(cursor) + + cursor.rollback() + cursor.close() + + def test0040active(self): + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + for record_id in record_ids: + if record_id % 2: + self.mptt.write(cursor, USER, record_id, { + 'active': False + }, CONTEXT) + self.CheckTree(cursor) + self.ReParent(cursor) + self.CheckTree(cursor) + self.ReOrder(cursor) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + self.mptt.write(cursor, USER, record_ids[:len(record_ids)/2], { + 'active': False + }, CONTEXT) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + self.mptt.write(cursor, USER, record_ids, { + 'active': False + }, CONTEXT) + self.ReParent(cursor) + self.CheckTree(cursor) + self.ReOrder(cursor) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + + def test0050delete(self): + ''' + Delete. + ''' + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + for record_id in record_ids: + if record_id % 2: + self.mptt.delete(cursor, USER, record_id, CONTEXT) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + self.mptt.delete(cursor, USER, record_ids[:len(record_ids)/2], CONTEXT) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + cursor = DB.cursor() + + record_ids = self.mptt.search(cursor, USER, [], 0, None, None, CONTEXT) + self.mptt.delete(cursor, USER, record_ids, CONTEXT) + self.CheckTree(cursor) + + cursor.rollback() + cursor.close() + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(MPTTTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/trytond/tests/test_pyson.py b/trytond/tests/test_pyson.py new file mode 100644 index 0000000000..cc8aa9a5b9 --- /dev/null +++ b/trytond/tests/test_pyson.py @@ -0,0 +1,545 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import unittest +import datetime +from trytond import pyson + + +class PYSONTestCase(unittest.TestCase): + ''' + Test PySON. + ''' + + def test0010Eval(self): + ''' + Test pyson.Eval + ''' + self.assert_(pyson.Eval('test').pyson() == { + '__class__': 'Eval', + 'v': 'test', + 'd': '', + }) + self.assert_(pyson.Eval('test', 'foo').pyson() == { + '__class__': 'Eval', + 'v': 'test', + 'd': 'foo', + }) + + self.assert_(pyson.Eval('test', 'foo').types() == set([type('foo')])) + self.assert_(pyson.Eval('test', 1).types() == set([type(1)])) + + eval = pyson.PYSONEncoder().encode(pyson.Eval('test', 0)) + self.assert_(pyson.PYSONDecoder({'test': 1}).decode(eval) == 1) + self.assert_(pyson.PYSONDecoder().decode(eval) == 0) + + def test0020Not(self): + ''' + Test pyson.Not + ''' + self.assert_(pyson.Not(True).pyson() == { + '__class__': 'Not', + 'v': True, + }) + + self.assertRaises(AssertionError, pyson.Not, 'foo') + + self.assert_(pyson.Not(True).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Not(True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Not(False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + def test0030Bool(self): + ''' + Test pyson.Bool + ''' + self.assert_(pyson.Bool('test').pyson() == { + '__class__': 'Bool', + 'v': 'test', + }) + + self.assert_(pyson.Bool('test').types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Bool(True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Bool(False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Bool('test')) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Bool('')) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Bool(1)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Bool(0)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Bool(['test'])) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Bool([])) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Bool({'foo': 'bar'})) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Bool({})) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + def test0040And(self): + ''' + Test pyson.And + ''' + self.assert_(pyson.And(True, False).pyson() == { + '__class__': 'And', + 's': (True, False), + }) + + self.assertRaises(AssertionError, pyson.And, 'test', False) + self.assertRaises(AssertionError, pyson.And, True, 'test') + self.assertRaises(AssertionError, pyson.And, True, False, 'test') + self.assertRaises(AssertionError, pyson.And, True) + self.assertRaises(AssertionError, pyson.And) + + self.assert_(pyson.And(True, False).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.And(True, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.And(True, True, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.And(True, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(False, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(False, False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(True, False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(False, True, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.And(False, False, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + def test0050Or(self): + ''' + Test pyson.Or + ''' + self.assert_(pyson.Or(True, False).pyson() == { + '__class__': 'Or', + 's': (True, False), + }) + + self.assertRaises(AssertionError, pyson.Or, 'test', False) + self.assertRaises(AssertionError, pyson.Or, True, 'test') + self.assertRaises(AssertionError, pyson.Or, True, False, 'test') + self.assertRaises(AssertionError, pyson.Or, True) + self.assertRaises(AssertionError, pyson.Or) + + self.assert_(pyson.Or(True, False).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Or(True, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(True, True, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(True, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(False, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Or(False, False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Or(True, False, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(False, True, False)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Or(False, False, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + def test0060Equal(self): + ''' + Test pyson.Equal + ''' + self.assert_(pyson.Equal('test', 'test').pyson() == { + '__class__': 'Equal', + 's1': 'test', + 's2': 'test', + }) + + self.assertRaises(AssertionError, pyson.Equal, 'test', True) + + self.assert_(pyson.Equal('test', 'test').types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Equal('test', 'test')) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Equal('foo', 'bar')) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + def test0070Greater(self): + ''' + Test pyson.Greater + ''' + self.assert_(pyson.Greater(1, 0).pyson() == { + '__class__': 'Greater', + 's1': 1, + 's2': 0, + 'e': False, + }) + + self.assertRaises(AssertionError, pyson.Greater, 'test', 0) + self.assertRaises(AssertionError, pyson.Greater, 1, 'test') + self.assertRaises(AssertionError, pyson.Greater, 1, 0, 'test') + + self.assert_(pyson.Greater(1, 0).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + def test0080Less(self): + ''' + Test pyson.Less + ''' + self.assert_(pyson.Less(0, 1).pyson() == { + '__class__': 'Less', + 's1': 0, + 's2': 1, + 'e': False, + }) + + self.assertRaises(AssertionError, pyson.Less, 'test', 1) + self.assertRaises(AssertionError, pyson.Less, 0, 'test') + self.assertRaises(AssertionError, pyson.Less, 0, 1, 'test') + + self.assert_(pyson.Less(0, 1).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1)) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1, True)) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + def test0090If(self): + ''' + Test pyson.If + ''' + self.assert_(pyson.If(True, 'foo', 'bar').pyson() == { + '__class__': 'If', + 'c': True, + 't': 'foo', + 'e': 'bar', + }) + + self.assertRaises(AssertionError, pyson.If, 'test', 'foo', 'bar') + self.assertRaises(AssertionError, pyson.If, True, 'foo', False) + + self.assert_(pyson.If(True, 'foo', 'bar').types() == set([type('foo')])) + self.assert_(pyson.If(True, False, True).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.If(True, 'foo', 'bar')) + self.assert_(pyson.PYSONDecoder().decode(eval) == 'foo') + + eval = pyson.PYSONEncoder().encode(pyson.If(False, 'foo', 'bar')) + self.assert_(pyson.PYSONDecoder().decode(eval) == 'bar') + + def test0100Get(self): + ''' + Test pyson.Get + ''' + self.assert_(pyson.Get({'foo': 'bar'}, 'foo', 'default').pyson() == { + '__class__': 'Get', + 'v': {'foo': 'bar'}, + 'k': 'foo', + 'd': 'default', + }) + + self.assertRaises(AssertionError, pyson.Get, 'test', 'foo', 'default') + self.assertRaises(AssertionError, pyson.Get, {}, 1, 'default') + + self.assert_(pyson.Get({}, 'foo', 'default').types() == set([str])) + self.assert_(pyson.Get({}, 'foo', True).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.Get( + {'foo': 'bar'}, 'foo', 'default')) + self.assert_(pyson.PYSONDecoder().decode(eval) == 'bar') + + eval = pyson.PYSONEncoder().encode(pyson.Get( + {'foo': 'bar'}, 'test', 'default')) + self.assert_(pyson.PYSONDecoder().decode(eval) == 'default') + + eval = pyson.PYSONEncoder().encode(pyson.Get( + {}, 'foo', 'default')) + self.assert_(pyson.PYSONDecoder().decode(eval) == 'default') + + def test0110In(self): + ''' + Test pyson.In + ''' + self.assert_(pyson.In('foo', {'foo': 'bar'}).pyson() == { + '__class__': 'In', + 'k': 'foo', + 'v': {'foo': 'bar'}, + }) + + self.assertRaises(AssertionError, pyson.In, object(), {}) + self.assertRaises(AssertionError, pyson.In, 'test', 'foo') + + self.assert_(pyson.In('foo', {}).types() == set([bool])) + + eval = pyson.PYSONEncoder().encode(pyson.In('foo', {'foo': 'bar'})) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.In('1', {1: 'bar'})) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.In('test', {'foo': 'bar'})) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.In('1', {2: 'bar'})) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.In('test', {})) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.In('foo', ['foo'])) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.In(1, [1])) + self.assert_(pyson.PYSONDecoder().decode(eval) == True) + + eval = pyson.PYSONEncoder().encode(pyson.In('test', ['foo'])) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.In(1, [2])) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + eval = pyson.PYSONEncoder().encode(pyson.In('test', [])) + self.assert_(pyson.PYSONDecoder().decode(eval) == False) + + def test0120Date(self): + ''' + Test pyson.Date + ''' + self.assert_(pyson.Date(2010, 1, 12, -1, 12, -7).pyson() == { + '__class__': 'Date', + 'y': 2010, + 'M': 1, + 'd': 12, + 'dy': -1, + 'dM': 12, + 'dd': -7 + }) + + self.assertRaises(AssertionError, pyson.Date, 'test', 1, 12, -1, 12, + -7) + self.assertRaises(AssertionError, pyson.Date, 2010, 'test', 12, -1, 12, + -7) + self.assertRaises(AssertionError, pyson.Date, 2010, 1, 'test', -1, 12, + -7) + self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, 'test', 12, + -7) + self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, -1, 'test', + -7) + self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, -1, 12, + 'test') + + self.assert_(pyson.Date(2010, 1, 12, -1, 12, -7).types() + == set([datetime.date])) + + eval = pyson.PYSONEncoder().encode(pyson.Date()) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date.today()) + + eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date(2010, 1, 12)) + + eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, -1)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date(2009, 1, 12)) + + eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, 0, 12)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date(2011, 1, 12)) + + eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, 0, 0, -7)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date(2010, 1, 5)) + + eval = pyson.PYSONEncoder().encode(datetime.date(2010, 2, 22)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.date(2010, 2, 22)) + + def test0130DateTime(self): + ''' + Test pyson.DateTime + ''' + self.assert_(pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, + -1, 12, -7, 2, 15, 30, 1).pyson() == { + '__class__': 'DateTime', + 'y': 2010, + 'M': 1, + 'd': 12, + 'h': 10, + 'm': 30, + 's': 20, + 'ms': 0, + 'dy': -1, + 'dM': 12, + 'dd': -7, + 'dh': 2, + 'dm': 15, + 'ds': 30, + 'dms': 1, + }) + + self.assertRaises(AssertionError, pyson.DateTime, 'test', 1, 12, 10, + 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 'test', 12, 10, + 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 'test', 10, + 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 'test', + 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, + 'test', 20, 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 'test', 0, -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 'test', -1, 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, 'test', 12, -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 'test', -7, 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 12, 'test', 2, 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 12, -7, 'test', 15, 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 12, -7, 2, 'test', 30, 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 12, -7, 2, 15, 'test', 1) + self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, + 20, 0, -1, 12, -7, 2, 15, 30, 'test') + + self.assert_(pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, + -1, 12, -7, 2, 15, 30, 1).types() == set([datetime.datetime])) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 12, 10, 30, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, -1)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2009, 1, 12, 10, 30, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 12)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2011, 1, 12, 10, 30, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 0, -7)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 5, 10, 30, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 0, 0, 12)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 12, 22, 30, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 0, 0, 0, -30)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 12, 10, 0, 20, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 0, 0, 0, 0, 30)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 12, 10, 30, 50, 0)) + + eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, + 10, 30, 20, 0, 0, 0, 0, 0, 0, 0, 200)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 1, 12, 10, 30, 20, 200)) + + eval = pyson.PYSONEncoder().encode(datetime.datetime( + 2010, 2, 22, 10, 30, 20, 200)) + self.assert_(pyson.PYSONDecoder().decode(eval) + == datetime.datetime(2010, 2, 22, 10, 30, 20, 200)) + + def test0900Composite(self): + ''' + Test Composite + ''' + + eval = pyson.PYSONEncoder().encode(['id', pyson.If(pyson.Not( + pyson.In('company', pyson.Eval('context', {}))), '=', '!='), + pyson.Get(pyson.Eval('context', {}), 'company', 0)]) + self.assert_(pyson.PYSONDecoder({'context': {'company': 1}} + ).decode(eval) == ['id', '!=', 1]) + self.assert_(pyson.PYSONDecoder({'context': {}} + ).decode(eval) == ['id', '=', 0]) + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(PYSONTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/trytond/tests/test_tools.py b/trytond/tests/test_tools.py new file mode 100644 index 0000000000..d04523ff45 --- /dev/null +++ b/trytond/tests/test_tools.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +#This file is part of Tryton. The COPYRIGHT file at the top level of +#this repository contains the full copyright notices and license terms. + +import unittest +import datetime +from trytond.tools import reduce_ids, safe_eval, datetime_strftime + + +class ToolsTestCase(unittest.TestCase): + ''' + Test tools. + ''' + + def test0000reduce_ids_empty(self): + ''' + Test reduce_ids empty list. + ''' + self.assert_(('(%s)', [False]) == reduce_ids('id', [])) + + def test0010reduce_ids_continue(self): + ''' + Test reduce_ids continue list. + ''' + self.assert_(('(((id >= %s) AND (id <= %s)))', [0, 9]) == \ + reduce_ids('id', range(10))) + + def test0020reduce_ids_one_hole(self): + ''' + Test reduce_ids continue list with one hole. + ''' + self.assert_(('(((id >= %s) AND (id <= %s)) OR ' \ + '((id >= %s) AND (id <= %s)))', [0, 9, 20, 29]) == \ + reduce_ids('id', range(10) + map(lambda x: x + 20, range(10)))) + + def test0030reduce_ids_short_continue(self): + ''' + Test reduce_ids short continue list. + ''' + self.assert_(('((id IN (%s,%s,%s,%s)))', [0, 1, 2, 3]) == \ + reduce_ids('id', range(4))) + + def test0040reduce_ids_complex(self): + ''' + Test reduce_ids complex list. + ''' + self.assert_(('(((id >= %s) AND (id <= %s)) OR ' \ + '(id IN (%s,%s,%s,%s,%s)))', [0, 14, 25, 26, 27, 28, 29]) == \ + reduce_ids('id', range(10) + map(lambda x: x + 25, range(5)) + \ + map(lambda x: x + 5, range(10)))) + + def test0050reduce_ids_complex_small_continue(self): + ''' + Test reduce_ids complex list with small continue. + ''' + self.assert_(('(((id >= %s) AND (id <= %s)) OR (id IN (%s,%s,%s,%s)))', + [1, 12, 15, 18, 19, 21]) == \ + reduce_ids('id', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, + 18, 19, 21])) + + def test0060safe_eval_builtin(self): + ''' + Attempt to access a unsafe builtin. + ''' + self.assertRaises(Exception, safe_eval, "open('test.txt', 'w')") + + def test0061safe_eval_getattr(self): + ''' + Attempt to get arround direct attr access. + ''' + self.assertRaises(Exception, safe_eval, "getattr(int, '__abs__')") + + def test0062safe_eval_func_globals(self): + ''' + Attempt to access global enviroment where fun was defined. + ''' + self.assertRaises(Exception, safe_eval, + "def x(): pass; print x.func_globals") + + def test0063safe_eval_lowlevel(self): + ''' + Lowlevel tricks to access 'object'. + ''' + self.assertRaises(Exception, safe_eval, + "().__class__.mro()[1].__subclasses__()") + + def test0070datetime_strftime(self): + ''' + Test datetime_strftime + ''' + self.assert_(datetime_strftime(datetime.date(2005, 3, 2), + '%Y-%m-%d'), '2005-03-02') + self.assert_(datetime_strftime(datetime.date(1805, 3, 2), + '%Y-%m-%d'), '1805-03-02') + +def suite(): + return unittest.TestLoader().loadTestsFromTestCase(ToolsTestCase) + +if __name__ == '__main__': + suite = suite() + unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/trytond/tests/test_tryton.py b/trytond/tests/test_tryton.py index 3a3796dd7a..0666b0fd26 100644 --- a/trytond/tests/test_tryton.py +++ b/trytond/tests/test_tryton.py @@ -3,6 +3,9 @@ #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 logging +logging.basicConfig(level=logging.FATAL) + import sys, os DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..', '..', '..', 'trytond'))) @@ -10,26 +13,41 @@ if os.path.isdir(DIR): sys.path.insert(0, os.path.dirname(DIR)) import unittest -import time -from decimal import Decimal -from trytond import pysocket -from trytond.tools import reduce_ids, safe_eval, datetime_strftime -from trytond import pyson from lxml import etree -import datetime +import time +import imp +import zipimport -ADMIN_PASSWORD = 'admin' -HOST = '127.0.0.1' -PORT = '8070' -DB_NAME = 'test_' + str(int(time.time())) -USERNAME = 'admin' -PASSWORD = 'admin' +_MODULES = False +if __name__ == '__main__': + if '--modules' in sys.argv: + sys.argv.remove('--modules') + _MODULES = True + +from trytond.config import CONFIG +CONFIG['db_type'] = 'sqlite' +CONFIG.parse() +if not CONFIG['admin_passwd']: + CONFIG['admin_passwd'] = 'admin' + +from trytond.modules import register_classes +from trytond.pool import Pool +from trytond.backend import Database +from trytond.protocols.dispatcher import create + +register_classes() + +if CONFIG['db_type'] == 'sqlite': + DB_NAME = ':memory:' +else: + DB_NAME = 'test_' + str(int(time.time())) +USER = 1 +USER_PASSWORD = 'admin' CONTEXT = {} -USER = None -SESSION = None +DB = Database(DB_NAME) +Pool.test = True +POOL = Pool(DB_NAME) -SOCK = pysocket.PySocket() -SOCK.connect(HOST, PORT) class DBTestCase(unittest.TestCase): ''' @@ -40,2573 +58,8 @@ class DBTestCase(unittest.TestCase): ''' Create database. ''' - SOCK.send((None, None, None, 'common', 'db', 'create', DB_NAME, - ADMIN_PASSWORD, 'en_US', PASSWORD)) - res = SOCK.receive() - self.assert_(res) - - def test0020list(self): - ''' - List databases. - ''' - SOCK.send((None, None, None, 'common', 'db', 'list')) - res = SOCK.receive() - self.assert_(DB_NAME in res) - - def test0030login(self): - ''' - Login. - ''' - login() - - -class ToolsTestCase(unittest.TestCase): - ''' - Test tools. - ''' - - def test0000reduce_ids_empty(self): - ''' - Test reduce_ids empty list. - ''' - self.assert_(('(%s)', [False]) == reduce_ids('id', [])) - - def test0010reduce_ids_continue(self): - ''' - Test reduce_ids continue list. - ''' - self.assert_(('(((id >= %s) AND (id <= %s)))', [0, 9]) == \ - reduce_ids('id', range(10))) - - def test0020reduce_ids_one_hole(self): - ''' - Test reduce_ids continue list with one hole. - ''' - self.assert_(('(((id >= %s) AND (id <= %s)) OR ' \ - '((id >= %s) AND (id <= %s)))', [0, 9, 20, 29]) == \ - reduce_ids('id', range(10) + map(lambda x: x + 20, range(10)))) - - def test0030reduce_ids_short_continue(self): - ''' - Test reduce_ids short continue list. - ''' - self.assert_(('((id IN (%s,%s,%s,%s)))', [0, 1, 2, 3]) == \ - reduce_ids('id', range(4))) - - def test0040reduce_ids_complex(self): - ''' - Test reduce_ids complex list. - ''' - self.assert_(('(((id >= %s) AND (id <= %s)) OR ' \ - '(id IN (%s,%s,%s,%s,%s)))', [0, 14, 25, 26, 27, 28, 29]) == \ - reduce_ids('id', range(10) + map(lambda x: x + 25, range(5)) + \ - map(lambda x: x + 5, range(10)))) - - def test0050reduce_ids_complex_small_continue(self): - ''' - Test reduce_ids complex list with small continue. - ''' - self.assert_(('(((id >= %s) AND (id <= %s)) OR (id IN (%s,%s,%s,%s)))', - [1, 12, 15, 18, 19, 21]) == \ - reduce_ids('id', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, - 18, 19, 21])) - - def test0060safe_eval_builtin(self): - ''' - Attempt to access a unsafe builtin. - ''' - self.assertRaises(Exception, safe_eval, "open('test.txt', 'w')") - - def test0061safe_eval_getattr(self): - ''' - Attempt to get arround direct attr access. - ''' - self.assertRaises(Exception, safe_eval, "getattr(int, '__abs__')") - - def test0062safe_eval_func_globals(self): - ''' - Attempt to access global enviroment where fun was defined. - ''' - self.assertRaises(Exception, safe_eval, - "def x(): pass; print x.func_globals") - - def test0063safe_eval_lowlevel(self): - ''' - Lowlevel tricks to access 'object'. - ''' - self.assertRaises(Exception, safe_eval, - "().__class__.mro()[1].__subclasses__()") - - def test0070datetime_strftime(self): - ''' - Test datetime_strftime - ''' - self.assert_(datetime_strftime(datetime.date(2005, 3, 2), - '%Y-%m-%d'), '2005-03-02') - self.assert_(datetime_strftime(datetime.date(1805, 3, 2), - '%Y-%m-%d'), '1805-03-02') - -class PYSONTestCase(unittest.TestCase): - ''' - Test PySON. - ''' - - def test0010Eval(self): - ''' - Test pyson.Eval - ''' - self.assert_(pyson.Eval('test').pyson() == { - '__class__': 'Eval', - 'v': 'test', - 'd': '', - }) - self.assert_(pyson.Eval('test', 'foo').pyson() == { - '__class__': 'Eval', - 'v': 'test', - 'd': 'foo', - }) - - self.assert_(pyson.Eval('test', 'foo').types() == set([type('foo')])) - self.assert_(pyson.Eval('test', 1).types() == set([type(1)])) - - eval = pyson.PYSONEncoder().encode(pyson.Eval('test', 0)) - self.assert_(pyson.PYSONDecoder({'test': 1}).decode(eval) == 1) - self.assert_(pyson.PYSONDecoder().decode(eval) == 0) - - def test0020Not(self): - ''' - Test pyson.Not - ''' - self.assert_(pyson.Not(True).pyson() == { - '__class__': 'Not', - 'v': True, - }) - - self.assertRaises(AssertionError, pyson.Not, 'foo') - - self.assert_(pyson.Not(True).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Not(True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Not(False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - def test0030Bool(self): - ''' - Test pyson.Bool - ''' - self.assert_(pyson.Bool('test').pyson() == { - '__class__': 'Bool', - 'v': 'test', - }) - - self.assert_(pyson.Bool('test').types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Bool(True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Bool(False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Bool('test')) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Bool('')) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Bool(1)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Bool(0)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Bool(['test'])) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Bool([])) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Bool({'foo': 'bar'})) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Bool({})) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - def test0040And(self): - ''' - Test pyson.And - ''' - self.assert_(pyson.And(True, False).pyson() == { - '__class__': 'And', - 's': (True, False), - }) - - self.assertRaises(AssertionError, pyson.And, 'test', False) - self.assertRaises(AssertionError, pyson.And, True, 'test') - self.assertRaises(AssertionError, pyson.And, True, False, 'test') - self.assertRaises(AssertionError, pyson.And, True) - self.assertRaises(AssertionError, pyson.And) - - self.assert_(pyson.And(True, False).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.And(True, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.And(True, True, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.And(True, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(False, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(False, False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(True, False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(False, True, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.And(False, False, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - def test0050Or(self): - ''' - Test pyson.Or - ''' - self.assert_(pyson.Or(True, False).pyson() == { - '__class__': 'Or', - 's': (True, False), - }) - - self.assertRaises(AssertionError, pyson.Or, 'test', False) - self.assertRaises(AssertionError, pyson.Or, True, 'test') - self.assertRaises(AssertionError, pyson.Or, True, False, 'test') - self.assertRaises(AssertionError, pyson.Or, True) - self.assertRaises(AssertionError, pyson.Or) - - self.assert_(pyson.Or(True, False).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Or(True, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(True, True, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(True, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(False, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Or(False, False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Or(True, False, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(False, True, False)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Or(False, False, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - def test0060Equal(self): - ''' - Test pyson.Equal - ''' - self.assert_(pyson.Equal('test', 'test').pyson() == { - '__class__': 'Equal', - 's1': 'test', - 's2': 'test', - }) - - self.assertRaises(AssertionError, pyson.Equal, 'test', True) - - self.assert_(pyson.Equal('test', 'test').types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Equal('test', 'test')) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Equal('foo', 'bar')) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - def test0070Greater(self): - ''' - Test pyson.Greater - ''' - self.assert_(pyson.Greater(1, 0).pyson() == { - '__class__': 'Greater', - 's1': 1, - 's2': 0, - 'e': False, - }) - - self.assertRaises(AssertionError, pyson.Greater, 'test', 0) - self.assertRaises(AssertionError, pyson.Greater, 1, 'test') - self.assertRaises(AssertionError, pyson.Greater, 1, 0, 'test') - - self.assert_(pyson.Greater(1, 0).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - def test0080Less(self): - ''' - Test pyson.Less - ''' - self.assert_(pyson.Less(0, 1).pyson() == { - '__class__': 'Less', - 's1': 0, - 's2': 1, - 'e': False, - }) - - self.assertRaises(AssertionError, pyson.Less, 'test', 1) - self.assertRaises(AssertionError, pyson.Less, 0, 'test') - self.assertRaises(AssertionError, pyson.Less, 0, 1, 'test') - - self.assert_(pyson.Less(0, 1).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1)) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1, True)) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - def test0090If(self): - ''' - Test pyson.If - ''' - self.assert_(pyson.If(True, 'foo', 'bar').pyson() == { - '__class__': 'If', - 'c': True, - 't': 'foo', - 'e': 'bar', - }) - - self.assertRaises(AssertionError, pyson.If, 'test', 'foo', 'bar') - self.assertRaises(AssertionError, pyson.If, True, 'foo', False) - - self.assert_(pyson.If(True, 'foo', 'bar').types() == set([type('foo')])) - self.assert_(pyson.If(True, False, True).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.If(True, 'foo', 'bar')) - self.assert_(pyson.PYSONDecoder().decode(eval) == 'foo') - - eval = pyson.PYSONEncoder().encode(pyson.If(False, 'foo', 'bar')) - self.assert_(pyson.PYSONDecoder().decode(eval) == 'bar') - - def test0100Get(self): - ''' - Test pyson.Get - ''' - self.assert_(pyson.Get({'foo': 'bar'}, 'foo', 'default').pyson() == { - '__class__': 'Get', - 'v': {'foo': 'bar'}, - 'k': 'foo', - 'd': 'default', - }) - - self.assertRaises(AssertionError, pyson.Get, 'test', 'foo', 'default') - self.assertRaises(AssertionError, pyson.Get, {}, 1, 'default') - - self.assert_(pyson.Get({}, 'foo', 'default').types() == set([str])) - self.assert_(pyson.Get({}, 'foo', True).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.Get( - {'foo': 'bar'}, 'foo', 'default')) - self.assert_(pyson.PYSONDecoder().decode(eval) == 'bar') - - eval = pyson.PYSONEncoder().encode(pyson.Get( - {'foo': 'bar'}, 'test', 'default')) - self.assert_(pyson.PYSONDecoder().decode(eval) == 'default') - - eval = pyson.PYSONEncoder().encode(pyson.Get( - {}, 'foo', 'default')) - self.assert_(pyson.PYSONDecoder().decode(eval) == 'default') - - def test0110In(self): - ''' - Test pyson.In - ''' - self.assert_(pyson.In('foo', {'foo': 'bar'}).pyson() == { - '__class__': 'In', - 'k': 'foo', - 'v': {'foo': 'bar'}, - }) - - self.assertRaises(AssertionError, pyson.In, object(), {}) - self.assertRaises(AssertionError, pyson.In, 'test', 'foo') - - self.assert_(pyson.In('foo', {}).types() == set([bool])) - - eval = pyson.PYSONEncoder().encode(pyson.In('foo', {'foo': 'bar'})) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.In('1', {1: 'bar'})) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.In('test', {'foo': 'bar'})) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.In('1', {2: 'bar'})) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.In('test', {})) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.In('foo', ['foo'])) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.In(1, [1])) - self.assert_(pyson.PYSONDecoder().decode(eval) == True) - - eval = pyson.PYSONEncoder().encode(pyson.In('test', ['foo'])) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.In(1, [2])) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - eval = pyson.PYSONEncoder().encode(pyson.In('test', [])) - self.assert_(pyson.PYSONDecoder().decode(eval) == False) - - def test0120Date(self): - ''' - Test pyson.Date - ''' - self.assert_(pyson.Date(2010, 1, 12, -1, 12, -7).pyson() == { - '__class__': 'Date', - 'y': 2010, - 'M': 1, - 'd': 12, - 'dy': -1, - 'dM': 12, - 'dd': -7 - }) - - self.assertRaises(AssertionError, pyson.Date, 'test', 1, 12, -1, 12, -7) - self.assertRaises(AssertionError, pyson.Date, 2010, 'test', 12, -1, 12, -7) - self.assertRaises(AssertionError, pyson.Date, 2010, 1, 'test', -1, 12, -7) - self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, 'test', 12, -7) - self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, -1, 'test', -7) - self.assertRaises(AssertionError, pyson.Date, 2010, 1, 12, -1, 12, 'test') - - self.assert_(pyson.Date(2010, 1, 12, -1, 12, -7).types() - == set([datetime.date])) - - eval = pyson.PYSONEncoder().encode(pyson.Date()) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date.today()) - - eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date(2010, 1, 12)) - - eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, -1)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date(2009, 1, 12)) - - eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, 0, 12)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date(2011, 1, 12)) - - eval = pyson.PYSONEncoder().encode(pyson.Date(2010, 1, 12, 0, 0, -7)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date(2010, 1, 5)) - - eval = pyson.PYSONEncoder().encode(datetime.date(2010, 2, 22)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.date(2010, 2, 22)) - - def test0130DateTime(self): - ''' - Test pyson.DateTime - ''' - self.assert_(pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, - -1, 12, -7, 2, 15, 30, 1).pyson() == { - '__class__': 'DateTime', - 'y': 2010, - 'M': 1, - 'd': 12, - 'h': 10, - 'm': 30, - 's': 20, - 'ms': 0, - 'dy': -1, - 'dM': 12, - 'dd': -7, - 'dh': 2, - 'dm': 15, - 'ds': 30, - 'dms': 1, - }) - - self.assertRaises(AssertionError, pyson.DateTime, 'test', 1, 12, 10, - 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 'test', 12, 10, - 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 'test', 10, - 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 'test', - 30, 20, 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, - 'test', 20, 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 'test', 0, -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 'test', -1, 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, 'test', 12, -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 'test', -7, 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 12, 'test', 2, 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 12, -7, 'test', 15, 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 12, -7, 2, 'test', 30, 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 12, -7, 2, 15, 'test', 1) - self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30, - 20, 0, -1, 12, -7, 2, 15, 30, 'test') - - self.assert_(pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, - -1, 12, -7, 2, 15, 30, 1).types() == set([datetime.datetime])) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 12, 10, 30, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, -1)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2009, 1, 12, 10, 30, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 12)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2011, 1, 12, 10, 30, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 0, -7)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 5, 10, 30, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 0, 0, 12)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 12, 22, 30, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 0, 0, 0, -30)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 12, 10, 0, 20, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 0, 0, 0, 0, 30)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 12, 10, 30, 50, 0)) - - eval = pyson.PYSONEncoder().encode(pyson.DateTime(2010, 1, 12, - 10, 30, 20, 0, 0, 0, 0, 0, 0, 0, 200)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 1, 12, 10, 30, 20, 200)) - - eval = pyson.PYSONEncoder().encode(datetime.datetime( - 2010, 2, 22, 10, 30, 20, 200)) - self.assert_(pyson.PYSONDecoder().decode(eval) - == datetime.datetime(2010, 2, 22, 10, 30, 20, 200)) - - def test0900Composite(self): - ''' - Test Composite - ''' - - eval = pyson.PYSONEncoder().encode(['id', pyson.If(pyson.Not( - pyson.In('company', pyson.Eval('context', {}))), '=', '!='), - pyson.Get(pyson.Eval('context', {}), 'company', 0)]) - self.assert_(pyson.PYSONDecoder({'context': {'company': 1}} - ).decode(eval) == ['id', '!=', 1]) - self.assert_(pyson.PYSONDecoder({'context': {}} - ).decode(eval) == ['id', '=', 0]) - - -class FieldsTestCase(unittest.TestCase): - ''' - Test Fields. - ''' - - def setUp(self): - install_module('tests') - self.boolean = RPCProxy('tests.boolean') - self.boolean_default = RPCProxy('tests.boolean_default') - - self.integer = RPCProxy('tests.integer') - self.integer_default = RPCProxy('tests.integer_default') - self.integer_required = RPCProxy('tests.integer_required') - - self.float = RPCProxy('tests.float') - self.float_default = RPCProxy('tests.float_default') - self.float_required = RPCProxy('tests.float_required') - - self.numeric = RPCProxy('tests.numeric') - self.numeric_default = RPCProxy('tests.numeric_default') - self.numeric_required = RPCProxy('tests.numeric_required') - - self.char = RPCProxy('tests.char') - self.char_default = RPCProxy('tests.char_default') - self.char_required = RPCProxy('tests.char_required') - self.char_size = RPCProxy('tests.char_size') - - self.text = RPCProxy('tests.text') - self.text_default = RPCProxy('tests.text_default') - self.text_required = RPCProxy('tests.text_required') - self.text_size = RPCProxy('tests.text_size') - - self.sha = RPCProxy('tests.sha') - self.sha_default = RPCProxy('tests.sha_default') - self.sha_required = RPCProxy('tests.sha_required') - - self.date = RPCProxy('tests.date') - self.date_default = RPCProxy('tests.date_default') - self.date_required = RPCProxy('tests.date_required') - - self.datetime = RPCProxy('tests.datetime') - self.datetime_default = RPCProxy('tests.datetime_default') - self.datetime_required = RPCProxy('tests.datetime_required') - - def test0010boolean(self): - ''' - Test Boolean. - ''' - boolean1_id = self.boolean.create({ - 'boolean': True, - }, CONTEXT) - self.assert_(boolean1_id) - - boolean1 = self.boolean.read(boolean1_id, ['boolean'], CONTEXT) - self.assert_(boolean1['boolean'] == True) - - boolean_ids = self.boolean.search([ - ('boolean', '=', True), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == [boolean1_id]) - - boolean_ids = self.boolean.search([ - ('boolean', '!=', True), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == []) - - boolean_ids = self.boolean.search([ - ('boolean', 'in', [True]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == [boolean1_id]) - - boolean_ids = self.boolean.search([ - ('boolean', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == []) - - boolean_ids = self.boolean.search([ - ('boolean', 'not in', [True]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == []) - - boolean_ids = self.boolean.search([ - ('boolean', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == [boolean1_id]) - - boolean2_id = self.boolean.create({ - 'boolean': False, - }, CONTEXT) - self.assert_(boolean2_id) - - boolean2 = self.boolean.read(boolean2_id, ['boolean'], CONTEXT) - self.assert_(boolean2['boolean'] == False) - - boolean_ids = self.boolean.search([ - ('boolean', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == [boolean2_id]) - - boolean_ids = self.boolean.search([ - ('boolean', 'in', [True, False]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == [boolean1_id, boolean2_id]) - - boolean_ids = self.boolean.search([ - ('boolean', 'not in', [True, False]), - ], 0, None, None, CONTEXT) - self.assert_(boolean_ids == []) - - boolean3_id = self.boolean.create({}, CONTEXT) - self.assert_(boolean3_id) - - boolean3 = self.boolean.read(boolean3_id, ['boolean'], CONTEXT) - self.assert_(boolean3['boolean'] == False) - - boolean4_id = self.boolean_default.create({}, CONTEXT) - self.assert_(boolean4_id) - - boolean4 = self.boolean_default.read(boolean4_id, ['boolean'], CONTEXT) - self.assert_(boolean4['boolean'] == True) - - self.boolean.write(boolean1_id, { - 'boolean': False, - }, CONTEXT) - boolean1 = self.boolean.read(boolean1_id, ['boolean'], CONTEXT) - self.assert_(boolean1['boolean'] == False) - - self.boolean.write(boolean2_id, { - 'boolean': True, - }, CONTEXT) - boolean2 = self.boolean.read(boolean2_id, ['boolean'], CONTEXT) - self.assert_(boolean2['boolean'] == True) - - def test0020integer(self): - ''' - Test Integer. - ''' - integer1_id = self.integer.create({ - 'integer': 1, - }, CONTEXT) - self.assert_(integer1_id) - - integer1 = self.integer.read(integer1_id, ['integer'], CONTEXT) - self.assert_(integer1['integer'] == 1) - - integer_ids = self.integer.search([ - ('integer', '=', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '=', 0), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '!=', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '!=', 0), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', 'in', [1]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', 'in', [0]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', 'not in', [1]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', 'not in', [0]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '<', 5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '<', -5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '<', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '<=', 5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '<=', -5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '<=', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '>', 5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '>', -5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '>', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '>=', 5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer_ids = self.integer.search([ - ('integer', '>=', -5), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer_ids = self.integer.search([ - ('integer', '>=', 1), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id]) - - integer2_id = self.integer.create({ - 'integer': 0, - }, CONTEXT) - self.assert_(integer2_id) - - integer2 = self.integer.read(integer2_id, ['integer'], CONTEXT) - self.assert_(integer2['integer'] == 0) - - integer_ids = self.integer.search([ - ('integer', '=', 0), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer2_id]) - - integer_ids = self.integer.search([ - ('integer', 'in', [0, 1]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == [integer1_id, integer2_id]) - - integer_ids = self.integer.search([ - ('integer', 'not in', [0, 1]), - ], 0, None, None, CONTEXT) - self.assert_(integer_ids == []) - - integer3_id = self.integer.create({}, CONTEXT) - self.assert_(integer3_id) - - integer3 = self.integer.read(integer3_id, ['integer'], CONTEXT) - self.assert_(integer3['integer'] == 0) - - integer4_id = self.integer_default.create({}, CONTEXT) - self.assert_(integer4_id) - - integer4 = self.integer_default.read(integer4_id, ['integer'], CONTEXT) - self.assert_(integer4['integer'] == 5) - - self.integer.write(integer1_id, { - 'integer': 0, - }, CONTEXT) - integer1 = self.integer.read(integer1_id, ['integer'], CONTEXT) - self.assert_(integer1['integer'] == 0) - - self.integer.write(integer2_id, { - 'integer': 1, - }, CONTEXT) - integer2 = self.integer.read(integer2_id, ['integer'], CONTEXT) - self.assert_(integer2['integer'] == 1) - - self.failUnlessRaises(Exception, self.integer.create, { - 'integer': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.integer.write, integer1_id, { - 'integer': 'test', - }, CONTEXT) - - integer5_id = self.integer_required.create({}, CONTEXT) - self.assert_(integer5_id) - - integer5 = self.integer_required.read(integer5_id, ['integer'], CONTEXT) - self.assert_(integer5['integer'] == 0) - - def test0030float(self): - ''' - Test Float. - ''' - float1_id = self.float.create({ - 'float': 1.1, - }, CONTEXT) - self.assert_(float1_id) - - float1 = self.float.read(float1_id, ['float'], CONTEXT) - self.assert_(float1['float'] == 1.1) - - float_ids = self.float.search([ - ('float', '=', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '=', 0), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '!=', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '!=', 0), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', 'in', [1.1]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', 'in', [0]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', 'not in', [1.1]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', 'not in', [0]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '<', 5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '<', -5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '<', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '<=', 5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '<=', -5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '<=', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '>', 5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '>', -5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '>', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '>=', 5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float_ids = self.float.search([ - ('float', '>=', -5), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float_ids = self.float.search([ - ('float', '>=', 1.1), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id]) - - float2_id = self.float.create({ - 'float': 0, - }, CONTEXT) - self.assert_(float2_id) - - float2 = self.float.read(float2_id, ['float'], CONTEXT) - self.assert_(float2['float'] == 0) - - float_ids = self.float.search([ - ('float', '=', 0), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float2_id]) - - float_ids = self.float.search([ - ('float', 'in', [0, 1.1]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == [float1_id, float2_id]) - - float_ids = self.float.search([ - ('float', 'not in', [0, 1.1]), - ], 0, None, None, CONTEXT) - self.assert_(float_ids == []) - - float3_id = self.float.create({}, CONTEXT) - self.assert_(float3_id) - - float3 = self.float.read(float3_id, ['float'], CONTEXT) - self.assert_(float3['float'] == 0) - - float4_id = self.float_default.create({}, CONTEXT) - self.assert_(float4_id) - - float4 = self.float_default.read(float4_id, ['float'], CONTEXT) - self.assert_(float4['float'] == 5.5) - - self.float.write(float1_id, { - 'float': 0, - }, CONTEXT) - float1 = self.float.read(float1_id, ['float'] , CONTEXT) - self.assert_(float1['float'] == 0) - - self.float.write(float2_id, { - 'float': 1.1, - }, CONTEXT) - float2 = self.float.read(float2_id, ['float'], CONTEXT) - self.assert_(float2['float'] == 1.1) - - self.failUnlessRaises(Exception, self.float.create, { - 'float': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.float.write, float1_id, { - 'float': 'test', - }, CONTEXT) - - float5_id = self.float_required.create({}, CONTEXT) - self.assert_(float5_id) - - float5 = self.float_required.read(float5_id, ['float'], CONTEXT) - self.assert_(float5['float'] == 0) - - def test0040numeric(self): - ''' - Test Numeric. - ''' - numeric1_id = self.numeric.create({ - 'numeric': Decimal('1.1'), - }, CONTEXT) - self.assert_(numeric1_id) - - numeric1 = self.numeric.read(numeric1_id, ['numeric'], CONTEXT) - self.assert_(numeric1['numeric'] == Decimal('1.1')) - - numeric_ids = self.numeric.search([ - ('numeric', '=', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '=', Decimal('0')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '!=', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '!=', Decimal('0')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', 'in', [Decimal('1.1')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', 'in', [Decimal('0')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', 'not in', [Decimal('1.1')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', 'not in', [Decimal('0')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '<', Decimal('5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '<', Decimal('-5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '<', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '<=', Decimal('5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '<=', Decimal('-5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '<=', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '>', Decimal('5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '>', Decimal('-5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '>', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '>=', Decimal('5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric_ids = self.numeric.search([ - ('numeric', '>=', Decimal('-5')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric_ids = self.numeric.search([ - ('numeric', '>=', Decimal('1.1')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id]) - - numeric2_id = self.numeric.create({ - 'numeric': Decimal('0'), - }, CONTEXT) - self.assert_(numeric2_id) - - numeric2 = self.numeric.read(numeric2_id, ['numeric'], CONTEXT) - self.assert_(numeric2['numeric'] == Decimal('0')) - - numeric_ids = self.numeric.search([ - ('numeric', '=', Decimal('0')), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric2_id]) - - numeric_ids = self.numeric.search([ - ('numeric', 'in', [Decimal('0'), Decimal('1.1')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == [numeric1_id, numeric2_id]) - - numeric_ids = self.numeric.search([ - ('numeric', 'not in', [Decimal('0'), Decimal('1.1')]), - ], 0, None, None, CONTEXT) - self.assert_(numeric_ids == []) - - numeric3_id = self.numeric.create({}, CONTEXT) - self.assert_(numeric3_id) - - numeric3 = self.numeric.read(numeric3_id, ['numeric'], CONTEXT) - self.assert_(numeric3['numeric'] == Decimal('0')) - - numeric4_id = self.numeric_default.create({}, CONTEXT) - self.assert_(numeric4_id) - - numeric4 = self.numeric_default.read(numeric4_id, ['numeric'], CONTEXT) - self.assert_(numeric4['numeric'] == Decimal('5.5')) - - self.numeric.write(numeric1_id, { - 'numeric': Decimal('0'), - }, CONTEXT) - numeric1 = self.numeric.read(numeric1_id, ['numeric'] , CONTEXT) - self.assert_(numeric1['numeric'] == Decimal('0')) - - self.numeric.write(numeric2_id, { - 'numeric': Decimal('1.1'), - }, CONTEXT) - numeric2 = self.numeric.read(numeric2_id, ['numeric'], CONTEXT) - self.assert_(numeric2['numeric'] == Decimal('1.1')) - - self.failUnlessRaises(Exception, self.numeric.create, { - 'numeric': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.numeric.write, numeric1_id, { - 'numeric': 'test', - }, CONTEXT) - - numeric5_id = self.numeric_required.create({}, CONTEXT) - self.assert_(numeric5_id) - - numeric5 = self.numeric_required.read(numeric5_id, ['numeric'], CONTEXT) - self.assert_(numeric5['numeric'] == Decimal('0')) - - def test0050char(self): - ''' - Test Char. - ''' - char1_id = self.char.create({ - 'char': 'Test', - }, CONTEXT) - self.assert_(char1_id) - - char1 = self.char.read(char1_id, ['char'], CONTEXT) - self.assert_(char1['char'] == 'Test') - - char_ids = self.char.search([ - ('char', '=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', '=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', '!=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', '!=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', '!=', False), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'like', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'like', 'T%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'ilike', 'test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'ilike', 't%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not like', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not like', 'T%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'not like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'not ilike', 'test'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not ilike', 't%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char_ids = self.char.search([ - ('char', 'not ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char_ids = self.char.search([ - ('char', 'not ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id]) - - char2_id = self.char.create({ - 'char': False, - }, CONTEXT) - self.assert_(char2_id) - - char2 = self.char.read(char2_id, ['char'], CONTEXT) - self.assert_(char2['char'] == None) - - char_ids = self.char.search([ - ('char', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char2_id]) - - char_ids = self.char.search([ - ('char', 'in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char1_id, char2_id]) - - char_ids = self.char.search([ - ('char', 'not in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == []) - - char3_id = self.char.create({}, CONTEXT) - self.assert_(char3_id) - - char3 = self.char.read(char3_id, ['char'], CONTEXT) - self.assert_(char3['char'] == None) - - char4_id = self.char_default.create({}, CONTEXT) - self.assert_(char4_id) - - char4 = self.char_default.read(char4_id, ['char'], CONTEXT) - self.assert_(char4['char'] == 'Test') - - self.char.write(char1_id, { - 'char': False, - }, CONTEXT) - char1 = self.char.read(char1_id, ['char'], CONTEXT) - self.assert_(char1['char'] == None) - - self.char.write(char2_id, { - 'char': 'Test', - }, CONTEXT) - char2 = self.char.read(char2_id, ['char'], CONTEXT) - self.assert_(char2['char'] == 'Test') - - self.failUnlessRaises(Exception, self.char_required.create, {}, CONTEXT) - - char5_id = self.char_required.create({ - 'char': 'Test', - }, CONTEXT) - self.assert_(char5_id) - - char6_id = self.char_size.create({ - 'char': 'Test', - }, CONTEXT) - self.assert_(char6_id) - - self.failUnlessRaises(Exception, self.char_size.create, { - 'char': 'foobar', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.char_size.write, char6_id, { - 'char': 'foobar', - }, CONTEXT) - - char7_id = self.char.create({ - 'char': u'é', - }, CONTEXT) - self.assert_(char7_id) - - char7 = self.char.read(char7_id, ['char'], CONTEXT) - self.assert_(char7['char'] == u'é') - - char_ids = self.char.search([ - ('char', '=', u'é'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char7_id]) - - self.char.write(char7_id, { - 'char': 'é', - }, CONTEXT) - char7 = self.char.read(char7_id, ['char'], CONTEXT) - self.assert_(char7['char'] == u'é') - - char_ids = self.char.search([ - ('char', '=', 'é'), - ], 0, None, None, CONTEXT) - self.assert_(char_ids == [char7_id]) - - def test0060text(self): - ''' - Test Text. - ''' - text1_id = self.text.create({ - 'text': 'Test', - }, CONTEXT) - self.assert_(text1_id) - - text1 = self.text.read(text1_id, ['text'], CONTEXT) - self.assert_(text1['text'] == 'Test') - - text_ids = self.text.search([ - ('text', '=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', '=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', '!=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', '!=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', '!=', False), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'like', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'like', 'T%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'ilike', 'test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'ilike', 't%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not like', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not like', 'T%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'not like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'not ilike', 'test'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not ilike', 't%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text_ids = self.text.search([ - ('text', 'not ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text_ids = self.text.search([ - ('text', 'not ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id]) - - text2_id = self.text.create({ - 'text': False, - }, CONTEXT) - self.assert_(text2_id) - - text2 = self.text.read(text2_id, ['text'], CONTEXT) - self.assert_(text2['text'] == None) - - text_ids = self.text.search([ - ('text', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text2_id]) - - text_ids = self.text.search([ - ('text', 'in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text1_id, text2_id]) - - text_ids = self.text.search([ - ('text', 'not in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == []) - - text3_id = self.text.create({}, CONTEXT) - self.assert_(text3_id) - - text3 = self.text.read(text3_id, ['text'], CONTEXT) - self.assert_(text3['text'] == None) - - text4_id = self.text_default.create({}, CONTEXT) - self.assert_(text4_id) - - text4 = self.text_default.read(text4_id, ['text'], CONTEXT) - self.assert_(text4['text'] == 'Test') - - self.text.write(text1_id, { - 'text': False, - }, CONTEXT) - text1 = self.text.read(text1_id, ['text'], CONTEXT) - self.assert_(text1['text'] == None) - - self.text.write(text2_id, { - 'text': 'Test', - }, CONTEXT) - text2 = self.text.read(text2_id, ['text'], CONTEXT) - self.assert_(text2['text'] == 'Test') - - self.failUnlessRaises(Exception, self.text_required.create, {}, CONTEXT) - - text5_id = self.text_required.create({ - 'text': 'Test', - }, CONTEXT) - self.assert_(text5_id) - - text6_id = self.text_size.create({ - 'text': 'Test', - }, CONTEXT) - self.assert_(text6_id) - - self.failUnlessRaises(Exception, self.text_size.create, { - 'text': 'foobar', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.text_size.write, text6_id, { - 'text': 'foobar', - }, CONTEXT) - - text7_id = self.text.create({ - 'text': 'Foo\nBar', - }, CONTEXT) - self.assert_(text7_id) - - text8_id = self.text.create({ - 'text': u'é', - }, CONTEXT) - self.assert_(text8_id) - - text8 = self.text.read(text8_id, ['text'], CONTEXT) - self.assert_(text8['text'] == u'é') - - text_ids = self.text.search([ - ('text', '=', u'é'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text8_id]) - - self.text.write(text8_id, { - 'text': 'é', - }, CONTEXT) - text8 = self.text.read(text8_id, ['text'], CONTEXT) - self.assert_(text8['text'] == u'é') - - text_ids = self.text.search([ - ('text', '=', 'é'), - ], 0, None, None, CONTEXT) - self.assert_(text_ids == [text8_id]) - - def test0070sha(self): - ''' - Test Sha. - ''' - sha1_id = self.sha.create({ - 'sha': 'Test', - }, CONTEXT) - self.assert_(sha1_id) - - sha1 = self.sha.read(sha1_id, ['sha'], CONTEXT) - self.assert_(sha1['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') - - sha_ids = self.sha.search([ - ('sha', '=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', '=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', '!=', 'Test'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', '!=', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', '!=', False), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not in', ['Test']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not in', ['Foo']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'like', '640a%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'ilike', '640A%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not like', '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not like', '640a%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not like', 'Foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'not like', 'F%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'not ilike', '640AB2BAE07BEDC4C163F679A746F7AB7FB5D1FA'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not ilike', '640A%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha_ids = self.sha.search([ - ('sha', 'not ilike', 'foo'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha_ids = self.sha.search([ - ('sha', 'not ilike', 'f%'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id]) - - sha2_id = self.sha.create({ - 'sha': False, - }, CONTEXT) - self.assert_(sha2_id) - - sha2 = self.sha.read(sha2_id, ['sha'], CONTEXT) - self.assert_(sha2['sha'] == None) - - sha_ids = self.sha.search([ - ('sha', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha2_id]) - - sha_ids = self.sha.search([ - ('sha', 'in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha1_id, sha2_id]) - - sha_ids = self.sha.search([ - ('sha', 'not in', [False, 'Test']), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == []) - - sha3_id = self.sha.create({}, CONTEXT) - self.assert_(sha3_id) - - sha3 = self.sha.read(sha3_id, ['sha'], CONTEXT) - self.assert_(sha3['sha'] == None) - - sha4_id = self.sha_default.create({}, CONTEXT) - self.assert_(sha4_id) - - sha4 = self.sha_default.read(sha4_id, ['sha'], CONTEXT) - self.assert_(sha4['sha'] == 'ba79baeb9f10896a46ae74715271b7f586e74640') - - self.sha.write(sha1_id, { - 'sha': False, - }, CONTEXT) - sha1 = self.sha.read(sha1_id, ['sha'], CONTEXT) - self.assert_(sha1['sha'] == None) - - self.sha.write(sha2_id, { - 'sha': 'Test', - }, CONTEXT) - sha2 = self.sha.read(sha2_id, ['sha'], CONTEXT) - self.assert_(sha2['sha'] == '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') - - self.failUnlessRaises(Exception, self.sha_required.create, {}, CONTEXT) - - sha5_id = self.sha_required.create({ - 'sha': 'Test', - }, CONTEXT) - self.assert_(sha5_id) - - sha6_id = self.sha.create({ - 'sha': u'é', - }, CONTEXT) - self.assert_(sha6_id) - - sha6 = self.sha.read(sha6_id, ['sha'], CONTEXT) - self.assert_(sha6['sha'] == u'bf15be717ac1b080b4f1c456692825891ff5073d') - - sha_ids = self.sha.search([ - ('sha', '=', u'é'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha6_id]) - - self.sha.write(sha6_id, { - 'sha': 'é', - }, CONTEXT) - sha6 = self.sha.read(sha6_id, ['sha'], CONTEXT) - self.assert_(sha6['sha'] == u'bf15be717ac1b080b4f1c456692825891ff5073d') - - sha_ids = self.sha.search([ - ('sha', '=', 'é'), - ], 0, None, None, CONTEXT) - self.assert_(sha_ids == [sha6_id]) - - def test0080date(self): - ''' - Test Date. - ''' - today = datetime.date(2009, 1, 1) - tomorrow = today + datetime.timedelta(1) - yesterday = today - datetime.timedelta(1) - default_date = datetime.date(2000, 1, 1) - - date1_id = self.date.create({ - 'date': today, - }, CONTEXT) - self.assert_(date1_id) - - date1 = self.date.read(date1_id, ['date'], CONTEXT) - self.assert_(date1['date'] == today) - - date_ids = self.date.search([ - ('date', '=', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '!=', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '!=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '!=', False), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', 'in', [today]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', 'in', [tomorrow]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', 'not in', [today]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', 'not in', [tomorrow]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '<', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '<', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '<', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '<=', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '<=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '<=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '>', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '>', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '>', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '>=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date_ids = self.date.search([ - ('date', '>=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date_ids = self.date.search([ - ('date', '>=', today), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id]) - - date2_id = self.date.create({ - 'date': yesterday, - }, CONTEXT) - self.assert_(date2_id) - - date2 = self.date.read(date2_id, ['date'], CONTEXT) - self.assert_(date2['date'] == yesterday) - - date_ids = self.date.search([ - ('date', '=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date2_id]) - - date_ids = self.date.search([ - ('date', 'in', [yesterday, today]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == [date1_id, date2_id]) - - date_ids = self.date.search([ - ('date', 'not in', [yesterday, today]), - ], 0, None, None, CONTEXT) - self.assert_(date_ids == []) - - date3_id = self.date.create({}, CONTEXT) - self.assert_(date3_id) - - date3 = self.date.read(date3_id, ['date'], CONTEXT) - self.assert_(date3['date'] == None) - - date4_id = self.date_default.create({}, CONTEXT) - self.assert_(date4_id) - - date4 = self.date_default.read(date4_id, ['date'], CONTEXT) - self.assert_(date4['date'] == default_date) - - self.date.write(date1_id, { - 'date': yesterday, - }, CONTEXT) - date1 = self.date.read(date1_id, ['date'], CONTEXT) - self.assert_(date1['date'] == yesterday) - - self.date.write(date2_id, { - 'date': today, - }, CONTEXT) - date2 = self.date.read(date2_id, ['date'], CONTEXT) - self.assert_(date2['date'] == today) - - self.failUnlessRaises(Exception, self.date.create, { - 'date': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.write, date1_id, { - 'date': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.create, { - 'date': 1, - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.write, date1_id, { - 'date': 1, - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.create, { - 'date': datetime.datetime.now(), - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.write, date1_id, { - 'date': datetime.datetime.now(), - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.create, { - 'date': '2009-13-01', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.date.write, date1_id, { - 'date': '2009-02-29', - }, CONTEXT) - - date5_id = self.date.create({ - 'date': '2009-01-01', - }, CONTEXT) - self.assert_(date5_id) - date5 = self.date.read(date5_id, ['date'], CONTEXT) - self.assert_(date5['date'] == datetime.date(2009, 1, 1)) - - self.failUnlessRaises(Exception,self.date_required.create, {}, CONTEXT) - - date6_id = self.date_required.create({ - 'date': today, - }, CONTEXT) - self.assert_(date6_id) - - date7_id = self.date.create({ - 'date': None, - }, CONTEXT) - self.assert_(date7_id) - - date8_id = self.date.create({ - 'date': False, - }, CONTEXT) - self.assert_(date8_id) - - def test0090datetime(self): - ''' - Test DateTime. - ''' - 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_id = self.datetime.create({ - 'datetime': today, - }, CONTEXT) - self.assert_(datetime1_id) - - datetime1 = self.datetime.read(datetime1_id, ['datetime'], CONTEXT) - self.assert_(datetime1['datetime'] == today) - - datetime_ids = self.datetime.search([ - ('datetime', '=', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '=', False), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '!=', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '!=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '!=', False), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'in', [today]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'in', [tomorrow]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', 'in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', 'in', []), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', 'not in', [today]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', 'not in', [tomorrow]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'not in', [False]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'not in', []), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '<', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '<', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '<', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '<=', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '<=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '<=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '>', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '>', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '>', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '>=', tomorrow), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime_ids = self.datetime.search([ - ('datetime', '>=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime_ids = self.datetime.search([ - ('datetime', '>=', today), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id]) - - datetime2_id = self.datetime.create({ - 'datetime': yesterday, - }, CONTEXT) - self.assert_(datetime2_id) - - datetime2 = self.datetime.read(datetime2_id, ['datetime'], CONTEXT) - self.assert_(datetime2['datetime'] == yesterday) - - datetime_ids = self.datetime.search([ - ('datetime', '=', yesterday), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime2_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'in', [yesterday, today]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == [datetime1_id, datetime2_id]) - - datetime_ids = self.datetime.search([ - ('datetime', 'not in', [yesterday, today]), - ], 0, None, None, CONTEXT) - self.assert_(datetime_ids == []) - - datetime3_id = self.datetime.create({}, CONTEXT) - self.assert_(datetime3_id) - - datetime3 = self.datetime.read(datetime3_id, ['datetime'], CONTEXT) - self.assert_(datetime3['datetime'] == None) - - datetime4_id = self.datetime_default.create({}, CONTEXT) - self.assert_(datetime4_id) - - datetime4 = self.datetime_default.read(datetime4_id, ['datetime'], CONTEXT) - self.assert_(datetime4['datetime'] == default_datetime) - - self.datetime.write(datetime1_id, { - 'datetime': yesterday, - }, CONTEXT) - datetime1 = self.datetime.read(datetime1_id, ['datetime'], CONTEXT) - self.assert_(datetime1['datetime'] == yesterday) - - self.datetime.write(datetime2_id, { - 'datetime': today, - }, CONTEXT) - datetime2 = self.datetime.read(datetime2_id, ['datetime'], CONTEXT) - self.assert_(datetime2['datetime'] == today) - - self.failUnlessRaises(Exception, self.datetime.create, { - 'datetime': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.write, datetime1_id, { - 'datetime': 'test', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.create, { - 'datetime': 1, - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.write, datetime1_id, { - 'datetime': 1, - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.create, { - 'datetime': datetime.date.today(), - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.write, datetime1_id, { - 'datetime': datetime.date.today(), - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.create, { - 'datetime': '2009-13-01 12:30:00', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.write, datetime1_id, { - 'datetime': '2009-02-29 12:30:00', - }, CONTEXT) - - self.failUnlessRaises(Exception, self.datetime.write, datetime1_id, { - 'datetime': '2009-01-01 25:00:00', - }, CONTEXT) - - datetime5_id = self.datetime.create({ - 'datetime': '2009-01-01 12:00:00', - }, CONTEXT) - self.assert_(datetime5_id) - datetime5 = self.datetime.read(datetime5_id, ['datetime'], CONTEXT) - self.assert_(datetime5['datetime'] == datetime.datetime(2009, 1, 1, 12, - 0, 0)) - - self.failUnlessRaises(Exception,self.datetime_required.create, {}, CONTEXT) - - datetime6_id = self.datetime_required.create({ - 'datetime': today, - }, CONTEXT) - self.assert_(datetime6_id) - - datetime7_id = self.datetime.create({ - 'datetime': None, - }, CONTEXT) - self.assert_(datetime7_id) - - datetime8_id = self.datetime.create({ - 'datetime': False, - }, CONTEXT) - self.assert_(datetime8_id) + self.assert_(create(DB_NAME, USER_PASSWORD, 'en_US', + CONFIG['admin_passwd'])) class ModelViewTestCase(unittest.TestCase): @@ -2644,650 +97,18 @@ class ModelViewTestCase(unittest.TestCase): ''' test_view('webdav') - -class ModelSingletonTestCase(unittest.TestCase): - ''' - Test ModelSingleton - ''' - - def setUp(self): - install_module('tests') - self.singleton = RPCProxy('tests.singleton') - - def test0010read(self): - ''' - Test read method. - ''' - singleton = self.singleton.read(1, ['name'], CONTEXT) - self.assert_(singleton['name'] == 'test') - self.assert_(singleton['id'] == 1) - - singleton = self.singleton.read([1], ['name'], CONTEXT)[0] - self.assert_(singleton['name'] == 'test') - self.assert_(singleton['id'] == 1) - - def test0020create(self): - ''' - Test create method. - ''' - singleton_id = self.singleton.create({'name': 'bar'}, CONTEXT) - self.assert_(singleton_id) - - singleton = self.singleton.read(singleton_id, ['name'], CONTEXT) - self.assert_(singleton['name'] == 'bar') - - singleton2_id = self.singleton.create({'name': 'foo'}, CONTEXT) - self.assert_(singleton2_id == singleton_id) - - singleton = self.singleton.read(singleton_id, ['name'], CONTEXT) - self.assert_(singleton['name'] == 'foo') - - singleton_ids = self.singleton.search([], 0, None, None, CONTEXT) - self.assert_(len(singleton_ids) == 1) - - def test0030copy(self): - ''' - Test copy method. - ''' - singleton_id = self.singleton.search([], 0, None, None, CONTEXT)[0] - - singleton2_id = self.singleton.copy(singleton_id, None, CONTEXT) - self.assert_(singleton2_id == singleton_id) - - singleton_ids = self.singleton.search([], 0, None, None, CONTEXT) - self.assert_(len(singleton_ids) == 1) - - singleton3_id = self.singleton.copy(singleton_id, {'name': 'bar'}, - CONTEXT) - self.assert_(singleton3_id == singleton_id) - - singleton_ids = self.singleton.search([], 0, None, None, CONTEXT) - self.assert_(len(singleton_ids) == 1) - - def test0040default_get(self): - ''' - Test default_get method. - ''' - self.singleton.delete(self.singleton.search([], 0, None, None, - CONTEXT), CONTEXT) - - default = self.singleton.default_get(['name'], CONTEXT) - self.assert_(default == {'name': 'test'}) - - default = self.singleton.default_get(['create_uid'], CONTEXT) - self.assert_(len(default) == 2) - - default = self.singleton.default_get(['create_uid'], CONTEXT, False) - self.assert_(len(default) == 1) - - singleton_id = self.singleton.create({'name': 'bar'}, CONTEXT) - - default = self.singleton.default_get(['name'], CONTEXT) - self.assert_(default == {'name': 'bar'}) - - default = self.singleton.default_get(['create_uid'], CONTEXT) - self.assert_(len(default) == 2) - - default = self.singleton.default_get(['create_uid'], CONTEXT, False) - self.assert_(len(default) == 1) - - def test0050search(self): - ''' - Test search method. - ''' - self.singleton.delete(self.singleton.search([], 0, None, None, - CONTEXT), CONTEXT) - - singleton_ids = self.singleton.search([], 0, None, None, CONTEXT) - self.assert_(singleton_ids == [1]) - - singleton_ids = self.singleton.search([], 0, 1, None, CONTEXT) - self.assert_(singleton_ids == [1]) - - singleton_ids = self.singleton.search([], 0, None, None, CONTEXT, True) - self.assert_(singleton_ids == 1) - - -class MPTTTestCase(unittest.TestCase): - ''' - Test Modified Preorder Tree Traversal. - ''' - - def setUp(self): - install_module('tests') - self.mptt = RPCProxy('tests.mptt') - - def CheckTree(self, parent_id=False, left=0, right=0): - child_ids = self.mptt.search([ - ('parent', '=', parent_id), - ], 0, None, None, CONTEXT) - childs = self.mptt.read(child_ids, ['left', 'right'], CONTEXT) - childs.sort(lambda x, y: cmp(child_ids.index(x['id']), - child_ids.index(y['id']))) - for child in childs: - assert child['left'] > left, \ - 'Record (%d): left %d <= parent left %d' % \ - (child['id'], child['left'], left) - assert child['left'] < child['right'], \ - 'Record (%d): left %d >= right %d' % \ - (child['id'], child['left'], child['right']) - assert right == 0 or child['right'] < right, \ - 'Record (%d): right %d >= parent right %d' % \ - (child['id'], child['right'], right) - self.CheckTree(child['id'], left=child['left'], - right=child['right']) - next_left = 0 - for child in childs: - assert child['left'] > next_left, \ - 'Record (%d): left %d <= next left %d' % \ - (child['id'], child['left'], next_left) - next_left = child['right'] - childs.reverse() - previous_right = 0 - for child in childs: - assert previous_right == 0 or child['right'] < previous_right, \ - 'Record (%d): right %d >= previous right %d' % \ - (child['id'] , child['right'], previous_right) - previous_right = child['left'] - - - def ReParent(self, parent_id=False): - record_ids = self.mptt.search([ - ('parent', '=', parent_id), - ], 0, None, None, CONTEXT) - if not record_ids: - return - for record_id in record_ids: - for record2_id in record_ids: - if record_id != record2_id: - self.mptt.write(record_id, { - 'parent': record2_id, - }, CONTEXT) - self.CheckTree() - self.mptt.write(record_id, { - 'parent': parent_id, - }, CONTEXT) - self.CheckTree() - for record_id in record_ids: - self.ReParent(record_id) - - def ReOrder(self, parent_id=False): - record_ids = self.mptt.search([ - ('parent', '=', parent_id), - ], 0, None, None, CONTEXT) - if not record_ids: - return - i = len(record_ids) - for record_id in record_ids: - self.mptt.write(record_id, { - 'sequence': i, - }, CONTEXT) - i -= 1 - self.CheckTree() - i = 0 - for record_id in record_ids: - self.mptt.write(record_id, { - 'sequence': i, - }, CONTEXT) - i += 1 - self.CheckTree() - for record_id in record_ids: - self.ReOrder(record_id) - - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - self.mptt.write(record_ids, { - 'sequence': 0, - }, CONTEXT) - self.CheckTree() - - def test0010create(self): - ''' - Create tree. - ''' - new_records = [False] - for j in range(3): - parent_records = new_records - new_records = [] - k = 0 - for parent_record in parent_records: - for i in range(3): - record_id = self.mptt.create({ - 'name': 'Test %d %d %d' % (j, k, i), - 'parent': parent_record, - }, CONTEXT) - new_records.append(record_id) - k += 1 - self.CheckTree() - - def test0020reorder(self): - ''' - Re-order. - ''' - self.ReOrder() - - def test0030reparent(self): - ''' - Re-parent. - ''' - self.ReParent() - - def test0040active(self): - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - for record_id in record_ids: - if record_id % 2: - self.mptt.write(record_id, { - 'active': False - }, CONTEXT) - self.CheckTree() - - self.ReParent() - self.ReOrder() - - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - self.mptt.write(record_ids[:len(record_ids)/2], { - 'active': False - }, CONTEXT) - self.CheckTree() - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - self.mptt.write(record_ids, { - 'active': False - }, CONTEXT) - - - self.ReParent() - self.ReOrder() - - record_ids = self.mptt.search([ - ('active', '=', False), - ], 0, None, None, CONTEXT) - self.mptt.write(record_ids, { - 'active': False - }, CONTEXT) - self.CheckTree() - - def test0050delete(self): - ''' - Delete. - ''' - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - for record_id in record_ids: - if record_id % 2: - self.mptt.delete(record_id, CONTEXT) - self.CheckTree() - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - self.mptt.delete(record_ids[:len(record_ids)/2], CONTEXT) - self.CheckTree() - record_ids = self.mptt.search([], 0, None, None, CONTEXT) - self.mptt.delete(record_ids, CONTEXT) - self.CheckTree() - - -class ImportDataTestCase(unittest.TestCase): - ''' - Test import_data. - ''' - - def setUp(self): - install_module('tests') - self.boolean = RPCProxy('tests.import_data.boolean') - self.integer = RPCProxy('tests.import_data.integer') - self.float = RPCProxy('tests.import_data.float') - self.numeric = RPCProxy('tests.import_data.numeric') - self.char = RPCProxy('tests.import_data.char') - self.text = RPCProxy('tests.import_data.text') - self.sha = RPCProxy('tests.import_data.sha') - self.date = RPCProxy('tests.import_data.date') - self.datetime = RPCProxy('tests.import_data.datetime') - self.selection = RPCProxy('tests.import_data.selection') - self.many2one = RPCProxy('tests.import_data.many2one') - self.many2many = RPCProxy('tests.import_data.many2many') - self.one2many = RPCProxy('tests.import_data.one2many') - self.reference = RPCProxy('tests.import_data.reference') - - def test0010boolean(self): - ''' - Test boolean. - ''' - self.assert_(self.boolean.import_data(['boolean'], [['True']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], [['1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], [['False']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], [['0']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], - [['True'], ['False']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.boolean.import_data(['boolean'], [['foo']], - CONTEXT)[0] == -1) - - def test0020integer(self): - ''' - Test integer. - ''' - self.assert_(self.integer.import_data(['integer'], [['1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.integer.import_data(['integer'], [['-1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.integer.import_data(['integer'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.integer.import_data(['integer'], - [['1'], ['2']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.integer.import_data(['integer'], [['1.1']], - CONTEXT)[0] == -1) - - self.assert_(self.integer.import_data(['integer'], [['-1.1']], - CONTEXT)[0] == -1) - - self.assert_(self.integer.import_data(['integer'], [['foo']], - CONTEXT)[0] == -1) - - def test0030float(self): - ''' - Test float. - ''' - self.assert_(self.float.import_data(['float'], [['1.1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.float.import_data(['float'], [['-1.1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.float.import_data(['float'], [['1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.float.import_data(['float'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.float.import_data(['float'], - [['1.1'], ['2.2']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.float.import_data(['float'], [['foo']], CONTEXT)[0] - == -1) - - def test0040numeric(self): - ''' - Test numeric. - ''' - self.assert_(self.numeric.import_data(['numeric'], [['1.1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.numeric.import_data(['numeric'], [['-1.1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.numeric.import_data(['numeric'], [['1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.numeric.import_data(['numeric'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.numeric.import_data(['numeric'], - [['1.1'], ['2.2']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.numeric.import_data(['numeric'], [['foo']], - CONTEXT)[0] == -1) - - def test0050char(self): - ''' - Test char. - ''' - self.assert_(self.char.import_data(['char'], [['test']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.char.import_data(['char'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.char.import_data(['char'], - [['test'], ['foo'], ['bar']], CONTEXT) == (3, 0, 0, 0)) - - def test0060text(self): - ''' - Test text. - ''' - self.assert_(self.text.import_data(['text'], [['test']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.text.import_data(['text'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.text.import_data(['text'], - [['test'], ['foo'], ['bar']], CONTEXT) == (3, 0, 0, 0)) - - def test0070sha(self): - ''' - Test sha. - ''' - self.assert_(self.sha.import_data(['sha'], [['test']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.sha.import_data(['sha'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.sha.import_data(['sha'], - [['test'], ['foo']], CONTEXT) == (2, 0, 0, 0)) - - def test0080date(self): - ''' - Test date. - ''' - self.assert_(self.date.import_data(['date'], [['2010-01-01']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.date.import_data(['date'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.date.import_data(['date'], [ - ['2010-01-01'], ['2010-02-01']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.date.import_data(['date'], [['foo']], CONTEXT)[0] - == -1) - - def test0090datetime(self): - ''' - Test datetime. - ''' - self.assert_(self.datetime.import_data(['datetime'], - [['2010-01-01 12:00:00']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.datetime.import_data(['datetime'], [['']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.datetime.import_data(['datetime'], - [['2010-01-01 12:00:00'], ['2010-01-01 13:30:00']], CONTEXT) - == (2, 0, 0, 0)) - - self.assert_(self.datetime.import_data(['datetime'], [['foo']], - CONTEXT)[0] == -1) - - def test0100selection(self): - ''' - Test selection. - ''' - self.assert_(self.selection.import_data(['selection'], [['select1']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.selection.import_data(['selection'], [['']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.selection.import_data(['selection'], - [['select1'], ['select2']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.selection.import_data(['selection'], [['foo']], - CONTEXT)[0] == -1) - - def test0110many2one(self): - ''' - Test many2one. - ''' - self.assert_(self.many2one.import_data(['many2one'], [['Test']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2one.import_data(['many2one:id'], - [['tests.import_data_many2one_target_test']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.many2one.import_data(['many2one'], [['']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2one.import_data(['many2one'], - [['Test'], ['Test']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.many2one.import_data(['many2one'], [['foo']], - CONTEXT)[0] == -1) - - self.assert_(self.many2one.import_data(['many2one'], [['Duplicate']], - CONTEXT)[0] == -1) - - self.assert_(self.many2one.import_data(['many2one:id'], [['foo']], - CONTEXT)[0] == -1) - - self.assert_(self.many2one.import_data(['many2one:id'], - [['tests.foo']], CONTEXT)[0] == -1) - - def test0120many2many(self): - ''' - Test many2many. - ''' - self.assert_(self.many2many.import_data(['many2many'], [['Test 1']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many:id'], - [['tests.import_data_many2many_target_test1']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], - [['Test 1,Test 2']], CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many:id'], - [['tests.import_data_many2many_target_test1,' \ - 'tests.import_data_many2many_target_test2']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], - [['Test\, comma']], CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], - [['Test\, comma,Test 1']], CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], [['']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], - [['Test 1'], ['Test 2']], CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.many2many.import_data(['many2many'], [['foo']], - CONTEXT)[0] == -1) - - self.assert_(self.many2many.import_data(['many2many'], [['Test 1,foo']], - CONTEXT)[0] == -1) - - self.assert_(self.many2many.import_data(['many2many'], [['Duplicate']], - CONTEXT)[0] == -1) - - self.assert_(self.many2many.import_data(['many2many'], - [['Test 1,Duplicate']], CONTEXT)[0] == -1) - - def test0130one2many(self): - ''' - Test one2many. - ''' - self.assert_(self.one2many.import_data(['name', 'one2many/name'], - [['Test', 'Test 1']], CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.one2many.import_data(['name', 'one2many/name'], - [['Test', 'Test 1'], ['', 'Test 2']], CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.one2many.import_data(['name', 'one2many/name'], - [['Test 1', 'Test 1'], ['', 'Test 2'], - ['Test 2', 'Test 1']], CONTEXT) == (2, 0, 0, 0)) - - def test0140reference(self): - ''' - Test reference. - ''' - self.assert_(self.reference.import_data(['reference'], - [['tests.import_data.reference.selection,Test']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.reference.import_data(['reference:id'], - [['tests.import_data.reference.selection,'\ - 'tests.import_data_reference_selection_test']], CONTEXT) - == (1, 0, 0, 0)) - - self.assert_(self.reference.import_data(['reference'], [['']], - CONTEXT) == (1, 0, 0, 0)) - - self.assert_(self.reference.import_data(['reference'], - [['tests.import_data.reference.selection,Test'], - ['tests.import_data.reference.selection,Test']], - CONTEXT) == (2, 0, 0, 0)) - - self.assert_(self.reference.import_data(['reference'], - [['tests.import_data.reference.selection,foo']], - CONTEXT)[0] == -1) - - self.assert_(self.reference.import_data(['reference'], - [['tests.import_data.reference.selection,Duplicate']], - CONTEXT)[0] == -1) - - self.assert_(self.reference.import_data(['reference:id'], - [['tests.import_data.reference.selection,foo']], - CONTEXT)[0] == -1) - - self.assert_(self.reference.import_data(['reference:id'], - [['tests.import_data.reference.selection,tests.foo']], - CONTEXT)[0] == -1) - - -class RPCProxy(object): - - def __init__(self, name): - self.name = name - self.__attrs = {} - - def __getattr__(self, attr): - if attr not in self.__attrs: - self.__attrs[attr] = RPCFunction(self.name, attr) - return self.__attrs[attr] - - -class RPCFunction(object): - - def __init__(self, name, func_name): - self.name = name - self.func_name = func_name - - def __call__(self, *args): - SOCK.send((DB_NAME, USER, SESSION, 'model', self.name, self.func_name) \ - + args) - res = SOCK.receive() - return res - -def login(): - global USER, SESSION, CONTEXT - SOCK.send((DB_NAME, USERNAME, PASSWORD, 'common', 'db', 'login')) - USER, SESSION = SOCK.receive() - user = RPCProxy('res.user') - context = user.get_preferences(True, {}) - for i in context: - value = context[i] - CONTEXT[i] = value - def install_module(name): - module = RPCProxy('ir.module.module') - module_ids = module.search([ + ''' + Install module for the tested database + ''' + database = Database().connect() + cursor = database.cursor() + if DB_NAME not in database.list(cursor): + create(DB_NAME, 'admin', 'en_US', CONFIG['admin_passwd']) + cursor.close() + cursor = DB.cursor() + module_obj = POOL.get('ir.module.module') + module_ids = module_obj.search(cursor, USER, [ ('name', '=', name), ('state', '!=', 'installed'), ]) @@ -3295,58 +116,134 @@ def install_module(name): if not module_ids: return - module.button_install(module_ids, CONTEXT) + module_obj.button_install(cursor, USER, module_ids, CONTEXT) - SOCK.send((DB_NAME, USER, SESSION, 'wizard', - 'ir.module.module.install_upgrade', 'create')) - wiz_id = SOCK.receive() - - SOCK.send((DB_NAME, USER, SESSION, 'wizard', - 'ir.module.module.install_upgrade', 'execute', wiz_id, {}, 'start', - CONTEXT)) - SOCK.receive() - - SOCK.send((DB_NAME, USER, SESSION, 'wizard', - 'ir.module.module.install_upgrade', 'delete', wiz_id)) - SOCK.receive() + install_upgrade_obj = POOL.get('ir.module.module.install_upgrade', + type='wizard') + wiz_id = install_upgrade_obj.create(cursor, USER) + cursor.commit() + install_upgrade_obj.execute(cursor, USER, wiz_id, {}, 'start', CONTEXT) + install_upgrade_obj.delete(cursor, USER, wiz_id) + cursor.commit() + cursor.close() def test_view(module_name): - view_obj = RPCProxy('ir.ui.view') - view_ids = view_obj.search([ + ''' + Test validity of all views of the module + ''' + cursor = DB.cursor() + view_obj = POOL.get('ir.ui.view') + view_ids = view_obj.search(cursor, USER, [ ('module', '=', module_name), ]) - for view in view_obj.read(view_ids, ['id', 'model', 'inherit']): - view_id = view['inherit'] or view['id'] - model = view['model'] - model_obj = RPCProxy(model) - res = model_obj.fields_view_get(view_id) + for view in view_obj.browse(cursor, USER, view_ids, context=CONTEXT): + view_id = view.inherit and view.inherit.id or view.id + model = view.model + model_obj = POOL.get(model) + res = model_obj.fields_view_get(cursor, USER, view_id, context=CONTEXT) assert res['model'] == model tree = etree.fromstring(res['arch']) tree_root = tree.getroottree().getroot() - def check_tree(element): + for element in tree_root.iter(): if element.tag in ('field', 'label', 'separator', 'group'): for attr in ('name', 'icon'): field = element.get(attr) if field: assert field in res['fields'] - for child in element: - check_tree(child) - check_tree(tree_root) def suite(): - return unittest.TestLoader().loadTestsFromTestCase(DBTestCase) + ''' + Return test suite for other modules + ''' + # import module from root directory to be the same as in modules + import trytond.tests.test_tryton + return unittest.TestLoader().loadTestsFromTestCase( + trytond.tests.test_tryton.DBTestCase) + +def all_suite(): + ''' + Return all tests suite of current module + ''' + suite_ = suite() + import trytond.tests.test_tools as test_tools + suite_.addTests(test_tools.suite()) + import trytond.tests.test_pyson as test_pyson + suite_.addTests(test_pyson.suite()) + import trytond.tests.test_fields as test_fields + suite_.addTests(test_fields.suite()) + import trytond.tests.test_modelsingleton as test_modelsingleton + suite_.addTests(test_modelsingleton.suite()) + suite_.addTests(unittest.TestLoader( + ).loadTestsFromTestCase(ModelViewTestCase)) + import trytond.tests.test_mptt as test_mptt + suite_.addTests(test_mptt.suite()) + import trytond.tests.test_importdata as test_importdata + suite_.addTests(test_importdata.suite()) + return suite_ + +def modules_suite(): + ''' + Return all tests suite of all modules + ''' + suite_ = all_suite() + from trytond.modules import create_graph, get_module_list, \ + MODULES_PATH, EGG_MODULES + graph = create_graph(get_module_list())[0] + for package in graph: + module = package.name + test_module = 'trytond.modules.%s.tests.test_%s' % (module, module) + if os.path.isfile(os.path.join(MODULES_PATH, module + '.zip')): + mod_path = os.path.join(MODULES_PATH, module + '.zip') + zimp = zipimport.zipimporter(mod_path) + try: + test_mod = zimp.load_module(test_module) + except zipimport.ZipImportError: + continue + elif os.path.isdir(os.path.join(MODULES_PATH, module)): + try: + mod_file, pathname, description = imp.find_module( + 'tests', [os.path.join(MODULES_PATH, module)]) + except ImportError: + continue + try: + try: + test_mod = imp.load_module(test_module, mod_file, pathname, + description) + except ImportError: + continue + finally: + if mod_file is not None: + mod_file.close() + elif module in EGG_MODULES: + egg_p = EGG_MODULES[module] + mod_path = os.path.join(egg_p.dist.location, + *egg_p.module_name.split('.')[:-1]) + try: + mod_file, pathname, description = imp.find_module( + 'tests', [os.path.join(mod_path, module)]) + except ImportError: + continue + try: + try: + test_mod = imp.load_module(test_module, mod_file, pathname, + description) + except ImportError: + continue + finally: + if mod_file is not None: + mod_file.close() + else: + continue + for test in test_mod.suite(): + if test not in suite_: + suite_.addTest(test) + return suite_ if __name__ == '__main__': - suite = suite() - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(ToolsTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(PYSONTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(FieldsTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(ModelSingletonTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(ModelViewTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase(MPTTTestCase)) - suite.addTests(unittest.TestLoader().loadTestsFromTestCase( - ImportDataTestCase)) - unittest.TextTestRunner(verbosity=2).run(suite) - SOCK.disconnect() + if not _MODULES: + _SUITE = all_suite() + else: + _SUITE = modules_suite() + unittest.TextTestRunner(verbosity=2).run(_SUITE) diff --git a/trytond/tools/convert.py b/trytond/tools/convert.py index 7c2f25a816..dbd4c8b078 100644 --- a/trytond/tools/convert.py +++ b/trytond/tools/convert.py @@ -404,6 +404,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler): self.fs2db = Fs2bdAccessor(cursor, self.user, self.modeldata_obj, pool) self.to_delete = self.populate_to_delete() self.noupdate = None + self.skip_data = False # Tag handlders are used to delegate the processing self.taghandlerlist = { @@ -453,6 +454,11 @@ class TrytondXmlHandler(sax.handler.ContentHandler): elif name == "data": self.noupdate = bool(int(attributes.get("noupdate", '0'))) + if self.pool.test and \ + bool(int(attributes.get("skiptest", '0'))): + self.skip_data = True + else: + self.skip_data = False elif name == "tryton": pass @@ -461,7 +467,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler): logging.getLogger("convert").info( "Tag %s not supported" % name) return - else: + elif not self.skip_data: self.taghandler.startElement(name, attributes) def characters(self, data): @@ -472,7 +478,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler): # Closing tag found, if we are in a delegation the handler # know what to do: - if self.taghandler: + if self.taghandler and not self.skip_data: self.taghandler = self.taghandler.endElement(name) def current_state(self): diff --git a/trytond/tools/misc.py b/trytond/tools/misc.py index 5012b537be..6939f77d8b 100644 --- a/trytond/tools/misc.py +++ b/trytond/tools/misc.py @@ -94,7 +94,7 @@ def file_open(name, mode="r", subdir='modules'): or name.startswith('workflow' + os.sep) \ or name.startswith('res' + os.sep) \ or name.startswith('webdav' + os.sep) \ - or name.startswith('tests' + os.sep)): + or name.startswith('test' + os.sep)): name = os.path.join(root_path, name) else: name = os.path.join(root_path, subdir, name)