def test_ordered_search_same_timestamp(self): 'Test ordered search with same timestamp' pool = Pool() History = pool.get('test.history') transaction = Transaction() order = [('value', 'ASC')] history = History(value=1) history.save() first_stamp = history.create_date history.value = 4 history.save() second_stamp = history.write_date self.assertEqual(first_stamp, second_stamp) transaction.commit() results = [ (second_stamp, [history], [4]), (datetime.datetime.now(), [history], [4]), (datetime.datetime.max, [history], [4]), ] for timestamp, instances, values in results: with Transaction().set_context(_datetime=timestamp, last_test=True): records = History.search([], order=order) self.assertEqual(records, instances) self.assertEqual([x.value for x in records], values) transaction.rollback()
def test_integer_required(self): 'Test required integer' pool = Pool() IntegerRequired = pool.get('test.import_data.integer_required') transaction = Transaction() self.assertEqual(IntegerRequired.import_data(['integer'], [['1']]), 1) self.assertEqual(IntegerRequired.import_data(['integer'], [['-1']]), 1) self.assertRaises(UserError, IntegerRequired.import_data, ['integer'], [['']]) transaction.rollback() self.assertEqual(IntegerRequired.import_data(['integer'], [['1'], ['2']]), 2) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['1.1']]) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['-1.1']]) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['foo']]) self.assertEqual(IntegerRequired.import_data(['integer'], [['0']]), 1)
def test_numeric_required(self): 'Test required numeric' pool = Pool() NumericRequired = pool.get('test.import_data.numeric_required') transaction = Transaction() self.assertEqual(NumericRequired.import_data(['numeric'], [['1.1']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['-1.1']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['1']]), 1) self.assertRaises(UserError, NumericRequired.import_data, ['numeric'], [['']]) transaction.rollback() self.assertEqual(NumericRequired.import_data(['numeric'], [['1.1'], ['2.2']]), 2) self.assertRaises(InvalidOperation, NumericRequired.import_data, ['numeric'], [['foo']]) self.assertEqual(NumericRequired.import_data(['numeric'], [['0']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['0.0']]), 1)
def test_SMTPDataManager(self, get_smtp_server): "Test SMTPDataManager" transaction = Transaction() get_smtp_server.return_value = server = Mock() datamanager = transaction.join(SMTPDataManager()) # multiple join must return the same self.assertEqual(transaction.join(SMTPDataManager()), datamanager) msg1 = Mock(Message) msg2 = Mock(Message) datamanager.put("*****@*****.**", "*****@*****.**", msg1) datamanager.put("*****@*****.**", "*****@*****.**", msg2) transaction.commit() server.sendmail.assert_has_calls( [ call("*****@*****.**", "*****@*****.**", msg1.as_string()), call("*****@*****.**", "*****@*****.**", msg2.as_string()), ] ) server.quit.assert_called_once_with() self.assertFalse(datamanager.queue) server.reset_mock() datamanager.put("*****@*****.**", "*****@*****.**", Mock(Message)) transaction.rollback() server.sendmail.assert_not_called() self.assertFalse(datamanager.queue)
def test_float_required(self): 'Test required float' pool = Pool() FloatRequired = pool.get('test.import_data.float_required') transaction = Transaction() self.assertEqual(FloatRequired.import_data(['float'], [['1.1']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['-1.1']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['1']]), 1) self.assertRaises(UserError, FloatRequired.import_data, ['float'], [['']]) transaction.rollback() self.assertEqual(FloatRequired.import_data(['float'], [['1.1'], ['2.2']]), 2) self.assertRaises(ValueError, FloatRequired.import_data, ['float'], [['foo']]) self.assertEqual(FloatRequired.import_data(['float'], [['0']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['0.0']]), 1)
def wrapper(*args, **kwargs): transaction = Transaction() with transaction.start(DB_NAME, user, context=context): result = func(*args, **kwargs) transaction.rollback() # Drop the cache as the transaction is rollbacked Cache.drop(DB_NAME) return result
def post_import(pool, module, to_delete): """ Remove the records that are given in to_delete. """ transaction = Transaction() mdata_delete = [] ModelData = pool.get("ir.model.data") with Transaction().set_context(active_test=False): mdata = ModelData.search([ ('fs_id', 'in', to_delete), ('module', '=', module), ], order=[('id', 'DESC')]) for mrec in mdata: model, db_id, fs_id = mrec.model, mrec.db_id, mrec.fs_id logger.info('Deleting %s@%s from %s.%s', db_id, model, module, fs_id) try: # Deletion of the record try: Model = pool.get(model) except KeyError: Model = None if Model: Model.delete([Model(db_id)]) mdata_delete.append(mrec) else: logger.warning( 'Could not delete id %d of model %s because model no ' 'longer exists.', db_id, model) except Exception: transaction.rollback() logger.error( "Could not delete id %d from model %s.\n" "There may be a relation that points to this resource " "that must be manually fixed before restarting the update.", db_id, model, exc_info=True) if 'active' in Model._fields: try: Model.write([Model(db_id)], { 'active': False, }) except Exception: transaction.rollback() logger.error( 'Could not inactivate id: %d of model %s\n', db_id, model, exc_info=True) transaction.commit() # Clean model_data: if mdata_delete: ModelData.delete(mdata_delete) transaction.commit() return True
def test_MessageDataManager_rollback(self, get_twilio_client, sendmessage): "Test MessageDataManager rollback" transaction = Transaction() datamanager = transaction.join(twilio_messages.MessageDataManager()) message = {} datamanager.put(message) transaction.rollback() sendmessage.assert_not_called() self.assertFalse(datamanager.queue)
def _load_modules(): global res TableHandler = backend.get('TableHandler') cursor = Transaction().cursor # Migration from 3.6: remove double module old_table = 'ir_module_module' new_table = 'ir_module' if TableHandler.table_exist(cursor, old_table): TableHandler.table_rename(cursor, old_table, new_table) if update: cursor.execute(*ir_module.select(ir_module.name, where=ir_module.state.in_(('installed', 'to install', 'to upgrade', 'to remove')))) else: cursor.execute(*ir_module.select(ir_module.name, where=ir_module.state.in_(('installed', 'to upgrade', 'to remove')))) module_list = [name for (name,) in cursor.fetchall()] if update: module_list += update graph = create_graph(module_list)[0] try: load_module_graph(graph, pool, update, lang) except Exception: cursor.rollback() raise if update: cursor.execute(*ir_module.select(ir_module.name, where=(ir_module.state == 'to remove'))) fetchall = cursor.fetchall() if fetchall: for (mod_name,) in fetchall: # TODO check if ressource not updated by the user cursor.execute(*ir_model_data.select(ir_model_data.model, ir_model_data.db_id, where=(ir_model_data.module == mod_name), order_by=ir_model_data.id.desc)) for rmod, rid in cursor.fetchall(): Model = pool.get(rmod) Model.delete([Model(rid)]) cursor.commit() cursor.execute(*ir_module.update([ir_module.state], ['uninstalled'], where=(ir_module.state == 'to remove'))) cursor.commit() res = False Module = pool.get('ir.module') Module.update_list() cursor.commit() Cache.resets(database_name)
def post_import(pool, module, to_delete): """ Remove the records that are given in to_delete. """ cursor = Transaction().cursor mdata_delete = [] ModelData = pool.get("ir.model.data") with Transaction().set_context(active_test=False): mdata = ModelData.search([ ('fs_id', 'in', to_delete), ('module', '=', module), ], order=[('id', 'DESC')]) object_name_list = set(pool.object_name_list()) for mrec in mdata: model, db_id = mrec.model, mrec.db_id logging.getLogger("convert").info( 'Deleting %s@%s' % (db_id, model)) try: # Deletion of the record if model in object_name_list: Model = pool.get(model) Model.delete([Model(db_id)]) mdata_delete.append(mrec) else: logging.getLogger("convert").warning( 'Could not delete id %d of model %s because model no ' 'longer exists.' % (db_id, model)) cursor.commit() except Exception: cursor.rollback() tb_s = ''.join(traceback.format_exception(*sys.exc_info())) logging.getLogger("convert").error( 'Could not delete id: %d of model %s\n' 'There should be some relation ' 'that points to this resource\n' 'You should manually fix this ' 'and restart --update=module\n' 'Exception: %s' % (db_id, model, tb_s)) if 'active' in Model._fields: Model.write([Model(db_id)], { 'active': False, }) # Clean model_data: if mdata_delete: ModelData.delete(mdata_delete) cursor.commit() return True
def test_many2one(self): 'Test many2one' pool = Pool() Many2one = pool.get('test.import_data.many2one') transaction = Transaction() self.assertEqual(Many2one.import_data(['many2one'], [['Test']]), 1) self.assertEqual(Many2one.import_data(['many2one:id'], [['tests.import_data_many2one_target_test']]), 1) self.assertEqual(Many2one.import_data(['many2one'], [['']]), 1) self.assertEqual(Many2one.import_data(['many2one'], [['Test'], ['Test']]), 2) self.assertRaises(UserError, Many2one.import_data, ['many2one'], [['foo']]) transaction.rollback() self.assertRaises(UserError, Many2one.import_data, ['many2one'], [['Duplicate']]) transaction.rollback() self.assertRaises(UserError, Many2one.import_data, ['many2one:id'], [['foo']]) transaction.rollback() self.assertRaises(Exception, Many2one.import_data, ['many2one:id'], [['tests.foo']]) transaction.rollback()
def test_many2one(self): 'Test many2one' pool = Pool() Many2one = pool.get('test.import_data.many2one') transaction = Transaction() self.assertEqual(Many2one.import_data(['many2one'], [['Test']]), 1) self.assertEqual( Many2one.import_data(['many2one:id'], [['tests.import_data_many2one_target_test']]), 1) self.assertEqual(Many2one.import_data(['many2one'], [['']]), 1) self.assertEqual( Many2one.import_data(['many2one'], [['Test'], ['Test']]), 2) self.assertRaises(UserError, Many2one.import_data, ['many2one'], [['foo']]) transaction.rollback() self.assertRaises(UserError, Many2one.import_data, ['many2one'], [['Duplicate']]) transaction.rollback() self.assertRaises(UserError, Many2one.import_data, ['many2one:id'], [['foo']]) transaction.rollback() self.assertRaises(Exception, Many2one.import_data, ['many2one:id'], [['tests.foo']]) transaction.rollback()
def test_phone_number_format(self): 'Test phone number format' pool = Pool() Party = pool.get('party.party') ContactMechanism = pool.get('party.contact_mechanism') transaction = Transaction() def create(mtype, mvalue): party1, = Party.create([{ 'name': 'Party 1', }]) return ContactMechanism.create([{ 'party': party1.id, 'type': mtype, 'value': mvalue, }])[0] # Test format on create mechanism = create('phone', '+442083661177') self.assertEqual(mechanism.value, '+44 20 8366 1177') self.assertEqual(mechanism.value_compact, '+442083661177') # Test format on write mechanism.value = '+442083661178' mechanism.save() self.assertEqual(mechanism.value, '+44 20 8366 1178') self.assertEqual(mechanism.value_compact, '+442083661178') ContactMechanism.write([mechanism], { 'value': '+442083661179', }) self.assertEqual(mechanism.value, '+44 20 8366 1179') self.assertEqual(mechanism.value_compact, '+442083661179') # Test rejection of a phone type mechanism to non-phone value with self.assertRaises(UserError): mechanism.value = '*****@*****.**' mechanism.save() transaction.rollback() # Test rejection of invalid phone number creation with self.assertRaises(UserError): mechanism = create('phone', '*****@*****.**') transaction.rollback() # Test acceptance of a non-phone value when type is non-phone mechanism = create('email', '*****@*****.**')
def wrapper(*args, **kwargs): _db = Tdb._db _readonly = True if readonly is not None: _readonly = readonly elif 'request' in kwargs: _readonly = not (kwargs['request'].method in ('PUT', 'POST', 'DELETE', 'PATCH')) _user = user or 0 _context = {} _retry = Tdb._retry or 0 _is_open = (Transaction().cursor) if not _is_open: with Transaction().start(_db, 0): Cache.clean(_db) _context.update(default_context()) else: # Transaction().new_cursor(readonly=_readonly) pass _context.update(context or {}) # _context.update({'company': Tdb._company}) for count in range(_retry, -1, -1): with NoTransaction() if _is_open else Transaction().start( _db, _user, readonly=_readonly, context=_context): cursor = Transaction().cursor if withhold: cursor.cursor.withhold = True try: result = func(*args, **kwargs) if not _readonly: cursor.commit() except DatabaseOperationalError: cursor.rollback() if count and not _readonly: continue raise except Exception: cursor.rollback() raise Cache.resets(_db) return result
def test_required_field_missing(self): 'Test error message when a required field is missing' pool = Pool() Modelsql = pool.get('test.modelsql') transaction = Transaction() fields = { 'desc': '', 'integer': 0, } for key, value in fields.items(): try: Modelsql.create([{key: value}]) except UserError as err: # message must not quote key msg = "'%s' not missing but quoted in error: '%s'" % ( key, err.message) self.assertTrue(key not in err.message, msg) else: self.fail('UserError should be caught') transaction.rollback()
def test_required_field_missing(self): 'Test error message when a required field is missing' pool = Pool() Modelsql = pool.get('test.modelsql') transaction = Transaction() fields = { 'desc': '', 'integer': 0, } for key, value in fields.iteritems(): try: Modelsql.create([{key: value}]) except UserError, err: # message must not quote key msg = "'%s' not missing but quoted in error: '%s'" % (key, err.message) self.assertTrue(key not in err.message, msg) else: self.fail('UserError should be caught') transaction.rollback()
def transaction(request): """Yields transaction with installed module. """ # Importing transaction directly causes cyclic dependency in 3.6 from trytond.tests.test_tryton import USER, CONTEXT, DB_NAME, POOL from trytond.tools.singleton import Singleton # noqa from trytond.transaction import Transaction from trytond.cache import Cache # Inject helper functions in instance on which test function was collected. request.instance.POOL = POOL request.instance.USER = USER request.instance.CONTEXT = CONTEXT request.instance.DB_NAME = DB_NAME transaction = Transaction() with transaction.start(DB_NAME, USER, context=CONTEXT) as txn: yield txn transaction.rollback() Cache.drop(DB_NAME)
def test_many2many(self): 'Test many2many' pool = Pool() Many2many = pool.get('test.import_data.many2many') transaction = Transaction() self.assertEqual(Many2many.import_data(['many2many'], [['Test 1']]), 1) self.assertEqual( Many2many.import_data( ['many2many:id'], [['tests.import_data_many2many_target_test1']]), 1) self.assertEqual( Many2many.import_data(['many2many'], [['Test 1,Test 2']]), 1) self.assertEqual( Many2many.import_data(['many2many:id'], [[ 'tests.import_data_many2many_target_test1,' 'tests.import_data_many2many_target_test2' ]]), 1) self.assertEqual( Many2many.import_data(['many2many'], [['Test\\, comma']]), 1) self.assertEqual( Many2many.import_data(['many2many'], [['Test\\, comma,Test 1']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['']]), 1) self.assertEqual( Many2many.import_data(['many2many'], [['Test 1'], ['Test 2']]), 2) with self.assertRaises(ImportDataError): Many2many.import_data(['many2many'], [['foo']]) transaction.rollback() with self.assertRaises(ImportDataError): Many2many.import_data(['many2many'], [['Test 1,foo']]) transaction.rollback() with self.assertRaises(ImportDataError): Many2many.import_data(['many2many'], [['Duplicate']]) transaction.rollback() with self.assertRaises(ImportDataError): Many2many.import_data(['many2many'], [['Test 1,Duplicate']]) transaction.rollback()
def test_restore_history(self): 'Test restore history' pool = Pool() History = pool.get('test.history') transaction = Transaction() history = History(value=1) history.save() history_id = history.id first = history.create_date transaction.commit() history = History(history_id) history.value = 2 history.save() transaction.commit() History.restore_history([history_id], first) history = History(history_id) self.assertEqual(history.value, 1) transaction.rollback() History.restore_history([history_id], datetime.datetime.min) with self.assertRaises(AccessError): History.read([history_id], ['value']) transaction.rollback() History.delete([History(history_id)]) transaction.commit() History.restore_history([history_id], datetime.datetime.max) with self.assertRaises(AccessError): History.read([history_id], ['value'])
def test_integer_required(self): 'Test required integer' pool = Pool() IntegerRequired = pool.get('test.import_data.integer_required') transaction = Transaction() self.assertEqual(IntegerRequired.import_data(['integer'], [['1']]), 1) self.assertEqual(IntegerRequired.import_data(['integer'], [['-1']]), 1) with self.assertRaises(RequiredValidationError): IntegerRequired.import_data(['integer'], [['']]) transaction.rollback() self.assertEqual(IntegerRequired.import_data(['integer'], [['1'], ['2']]), 2) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['1.1']]) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['-1.1']]) self.assertRaises(ValueError, IntegerRequired.import_data, ['integer'], [['foo']]) self.assertEqual(IntegerRequired.import_data(['integer'], [['0']]), 1) self.assertEqual(IntegerRequired.import_data(['integer'], [[0]]), 1) with self.assertRaises(RequiredValidationError): IntegerRequired.import_data(['integer'], [[None]]) transaction.rollback()
def test_numeric_required(self): 'Test required numeric' pool = Pool() NumericRequired = pool.get('test.import_data.numeric_required') transaction = Transaction() self.assertEqual(NumericRequired.import_data(['numeric'], [['1.1']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['-1.1']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['1']]), 1) with self.assertRaises(RequiredValidationError): NumericRequired.import_data(['numeric'], [['']]) transaction.rollback() self.assertEqual(NumericRequired.import_data(['numeric'], [['1.1'], ['2.2']]), 2) self.assertRaises(InvalidOperation, NumericRequired.import_data, ['numeric'], [['foo']]) self.assertEqual(NumericRequired.import_data(['numeric'], [['0']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [['0.0']]), 1) self.assertEqual(NumericRequired.import_data(['numeric'], [[Decimal('0.0')]]), 1) with self.assertRaises(RequiredValidationError): NumericRequired.import_data(['numeric'], [[None]]) transaction.rollback()
def test_float_required(self): 'Test required float' pool = Pool() FloatRequired = pool.get('test.import_data.float_required') transaction = Transaction() self.assertEqual(FloatRequired.import_data(['float'], [['1.1']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['-1.1']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['1']]), 1) with self.assertRaises(RequiredValidationError): FloatRequired.import_data(['float'], [['']]) transaction.rollback() self.assertEqual(FloatRequired.import_data(['float'], [['1.1'], ['2.2']]), 2) self.assertRaises(ValueError, FloatRequired.import_data, ['float'], [['foo']]) self.assertEqual(FloatRequired.import_data(['float'], [['0']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [['0.0']]), 1) self.assertEqual(FloatRequired.import_data(['float'], [[0.0]]), 1) with self.assertRaises(RequiredValidationError): FloatRequired.import_data(['float'], [[None]]) transaction.rollback()
def test_restore_history(self): 'Test restore history' pool = Pool() History = pool.get('test.history') transaction = Transaction() history = History(value=1) history.save() history_id = history.id first = history.create_date transaction.commit() history = History(history_id) history.value = 2 history.save() transaction.commit() History.restore_history([history_id], first) history = History(history_id) self.assertEqual(history.value, 1) transaction.rollback() History.restore_history([history_id], datetime.datetime.min) self.assertRaises(UserError, History.read, [history_id]) transaction.rollback() History.delete([History(history_id)]) transaction.commit() History.restore_history([history_id], datetime.datetime.max) self.assertRaises(UserError, History.read, [history_id])
def test_product(self): pool = Pool() Recipe = pool.get('dish_recipe.recipe') Category = pool.get('dish_recipe.category') transaction = Transaction() category = Category(name='Category') product_1, unit = self._create_product('product_1', 'Unit') recipe = Recipe( name='Recipe', category=category, product=product_1, quantity=1.0, unit=unit, ) recipe.save() self.assertEqual(recipe.rec_name, 'Recipe') # Do not allow to use a product that already belongs to a recipe self.assertRaises(UserError, Recipe.create, [{ 'product': product_1.id, }]) transaction.rollback()
def test_many2many(self): 'Test many2many' pool = Pool() Many2many = pool.get('test.import_data.many2many') transaction = Transaction() self.assertEqual(Many2many.import_data(['many2many'], [['Test 1']]), 1) self.assertEqual(Many2many.import_data(['many2many:id'], [['tests.import_data_many2many_target_test1']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['Test 1,Test 2']]), 1) self.assertEqual(Many2many.import_data(['many2many:id'], [['tests.import_data_many2many_target_test1,' 'tests.import_data_many2many_target_test2']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['Test\, comma']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['Test\, comma,Test 1']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['']]), 1) self.assertEqual(Many2many.import_data(['many2many'], [['Test 1'], ['Test 2']]), 2) self.assertRaises(UserError, Many2many.import_data, ['many2many'], [['foo']]) transaction.rollback() self.assertRaises(UserError, Many2many.import_data, ['many2many'], [['Test 1,foo']]) transaction.rollback() self.assertRaises(UserError, Many2many.import_data, ['many2many'], [['Duplicate']]) transaction.rollback() self.assertRaises(UserError, Many2many.import_data, ['many2many'], [['Test 1,Duplicate']]) transaction.rollback()
def test_uom_non_zero_rate_factor(self): 'Test uom non_zero_rate_factor constraint' pool = Pool() UomCategory = pool.get('product.uom.category') Uom = pool.get('product.uom') transaction = Transaction() category, = UomCategory.create([{'name': 'Test'}]) self.assertRaises(Exception, Uom.create, [{ 'name': 'Test', 'symbol': 'T', 'category': category.id, 'rate': 0, 'factor': 0, }]) transaction.rollback() def create(): category, = UomCategory.create([{'name': 'Test'}]) return Uom.create([{ 'name': 'Test', 'symbol': 'T', 'category': category.id, 'rate': 1.0, 'factor': 1.0, }])[0] uom = create() self.assertRaises(Exception, Uom.write, [uom], { 'rate': 0.0, }) transaction.rollback() uom = create() self.assertRaises(Exception, Uom.write, [uom], { 'factor': 0.0, }) transaction.rollback() uom = create() self.assertRaises(Exception, Uom.write, [uom], { 'rate': 0.0, 'factor': 0.0, }) transaction.rollback()
def test_constraints(self): 'Test constraints' pool = Pool() Model = pool.get('ir.model') Trigger = pool.get('ir.trigger') transaction = Transaction() model, = Model.search([ ('model', '=', 'test.triggered'), ]) action_model, = Model.search([ ('model', '=', 'test.trigger_action'), ]) values = { 'name': 'Test', 'model': model.id, 'on_time': True, 'condition': 'true', 'action_model': action_model.id, 'action_function': 'test', } self.assertTrue(Trigger.create([values])) transaction.rollback() # on_exclusive for i in range(1, 4): for combination in combinations( ['create', 'write', 'delete'], i): combination_values = values.copy() for mode in combination: combination_values['on_%s' % mode] = True self.assertRaises(UserError, Trigger.create, [combination_values]) transaction.rollback() # check_condition condition_values = values.copy() condition_values['condition'] = '=' self.assertRaises(UserError, Trigger.create, [condition_values]) transaction.rollback() # Restart the cache on the get_triggers method of ir.trigger Trigger._get_triggers_cache.clear()
def test_reference(self): 'Test reference' pool = Pool() Reference = pool.get('test.import_data.reference') transaction = Transaction() self.assertEqual( Reference.import_data( ['reference'], [['test.import_data.reference.selection,Test']]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertEqual( Reference.import_data(['reference:id'], [[ 'test.import_data.reference.selection,' 'tests.import_data_reference_selection_test' ]]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertEqual(Reference.import_data(['reference'], [['']]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference, None) transaction.rollback() self.assertEqual( Reference.import_data( ['reference'], [['test.import_data.reference.selection,Test'], ['test.import_data.reference.selection,Test']]), 2) for reference in Reference.search([]): self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference'], [['test.import_data.reference.selection,foo']]) transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference'], [['test.import_data.reference.selection,Duplicate']]) transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference:id'], [['test.import_data.reference.selection,foo']]) transaction.rollback() self.assertRaises(Exception, Reference.import_data, ['reference:id'], [['test.import_data.reference.selection,test.foo']]) transaction.rollback()
def test_ordered_search(self): 'Test ordered search of history models' pool = Pool() History = pool.get('test.history') transaction = Transaction() order = [('value', 'ASC')] history = History(value=1) history.save() first_id = history.id first_stamp = history.create_date transaction.commit() history = History(value=2) history.save() second_id = history.id second_stamp = history.create_date transaction.commit() first, second = History.search([], order=order) self.assertEqual(first.id, first_id) self.assertEqual(second.id, second_id) first.value = 3 first.save() third_stamp = first.write_date transaction.commit() results = [ (first_stamp, [first]), (second_stamp, [first, second]), (third_stamp, [second, first]), (datetime.datetime.now(), [second, first]), (datetime.datetime.max, [second, first]), ] for timestamp, instances in results: with Transaction().set_context(_datetime=timestamp): records = History.search([], order=order) self.assertEqual(records, instances) transaction.rollback() to_delete, _ = History.search([], order=order) self.assertEqual(to_delete.id, second.id) History.delete([to_delete]) transaction.commit() results = [ (first_stamp, [first]), (second_stamp, [first, second]), (third_stamp, [second, first]), (datetime.datetime.now(), [first]), (datetime.datetime.max, [first]), ] for timestamp, instances in results: with Transaction().set_context(_datetime=timestamp, from_test=True): records = History.search([], order=order) self.assertEqual(records, instances) transaction.rollback()
def load_modules(database_name, pool, update=False, lang=None): res = True if not Transaction().cursor: contextmanager = Transaction().start(database_name, 0) else: contextmanager = contextlib.nested(Transaction().new_cursor(), Transaction().set_user(0), Transaction().reset_context()) with contextmanager: cursor = Transaction().cursor if update: # Migration from 2.2: workflow module removed cursor.execute('DELETE FROM ir_module_module ' 'WHERE name = %s', ('workflow',)) if 'all' in CONFIG['init']: cursor.execute("SELECT name FROM ir_module_module " "WHERE name != \'test\'") else: cursor.execute("SELECT name FROM ir_module_module " "WHERE state IN ('installed', 'to install', " "'to upgrade', 'to remove')") else: cursor.execute("SELECT name FROM ir_module_module " "WHERE state IN ('installed', 'to upgrade', 'to remove')") module_list = [name for (name,) in cursor.fetchall()] if update: for module in CONFIG['init'].keys(): if CONFIG['init'][module]: module_list.append(module) for module in CONFIG['update'].keys(): if CONFIG['update'][module]: module_list.append(module) graph = create_graph(module_list)[0] try: load_module_graph(graph, pool, lang) except Exception: cursor.rollback() raise if update: cursor.execute("SELECT name FROM ir_module_module " "WHERE state IN ('to remove')") fetchall = cursor.fetchall() if fetchall: for (mod_name,) in fetchall: #TODO check if ressource not updated by the user cursor.execute('SELECT model, db_id FROM ir_model_data ' 'WHERE module = %s ' 'ORDER BY id DESC', (mod_name,)) for rmod, rid in cursor.fetchall(): Model = pool.get(rmod) Model.delete([Model(rid)]) cursor.commit() cursor.execute("UPDATE ir_module_module SET state = %s " "WHERE state IN ('to remove')", ('uninstalled',)) cursor.commit() res = False Module = pool.get('ir.module.module') Module.update_list() cursor.commit() Cache.resets(database_name) return res
def test_reconciliation(self): pool = Pool() Account = pool.get('account.account') Receipt = pool.get('cash_bank.receipt') Reconciliation = pool.get('cash_bank.reconciliation') Line = pool.get('cash_bank.reconciliation.line') Config = pool.get('cash_bank.configuration') party = self._create_party('Party test', None) transaction = Transaction() company = create_company() with set_company(company): create_chart(company) create_fiscalyear(company) account_transfer, = Account.search([ ('name', '=', 'Main Expense'), ]) account_cash, = Account.search([ ('name', '=', 'Main Cash'), ]) account_revenue, = Account.search([ ('name', '=', 'Main Revenue'), ]) account_expense, = Account.search([ ('name', '=', 'Main Expense'), ]) config = Config(account_transfer=account_transfer) config.save() journal = create_journal(company, 'journal_cash') sequence = create_sequence('Cash/Bank Sequence', 'cash_bank.receipt', company) sequence_convertion = create_sequence('Cash/Bank Convertion', 'cash_bank.convertion', company) sequence_reconciliation = create_sequence( 'Cash/Bank Reconciliation', 'cash_bank.reconciliation', company) config.convertion_seq = sequence_convertion config.reconciliation_seq = sequence_reconciliation config.save() _, bank_account = create_bank_account( party_bank=self._create_party('Party Bank', None), party_owner=company.party) bank = create_cash_bank(company, 'Main Bank', 'bank', journal, account_cash, sequence, bank_account) self.assertEqual(len(bank.receipt_types), 2) date = datetime.date.today() rcps = [ self._get_receipt(company, bank, 'in', date, Decimal('100.0'), account_revenue), self._get_receipt(company, bank, 'in', date, Decimal('200.0'), account_revenue), self._get_receipt(company, bank, 'in', date, Decimal('300.0'), account_revenue), self._get_receipt(company, bank, 'in', date, Decimal('400.0'), account_revenue), self._get_receipt(company, bank, 'out', date, Decimal('10.0'), account_expense, party), self._get_receipt(company, bank, 'out', date, Decimal('20.0'), account_expense, party), ] Receipt.save(rcps) Receipt.confirm(rcps) recon = Reconciliation( company=company, cash_bank=bank, date=date, date_start=date, date_end=date, bank_balance=Decimal(600.0), last_bank_balance=Decimal(0.0), ) recon.save() Reconciliation.complete_lines([recon]) self.assertEqual(len(recon.lines), 6) transaction.commit() with self.assertRaises(UserError): # Diff != 0. There is no lines checked Reconciliation.confirm([recon]) transaction.rollback() lines = Line.search([ ('reconciliation', '=', recon.id), ('amount', 'in', [Decimal('100.0'), Decimal('200.0'), Decimal('300.0')]), ]) self.assertEqual(len(lines), 3) for line in lines: line.check = True Line.save(lines) recon.save() self.assertEqual(recon.diff, Decimal('0.0')) transaction.commit() with self.assertRaises(UserError): # Account move lines are not posted Reconciliation.confirm([recon]) transaction.rollback() Receipt.post(rcps) Reconciliation.confirm([recon]) # Account moves can not be posted if a confirmed reconciliation # invalidates them # Same date receipt = self._get_receipt(company, bank, 'in', date, Decimal('99.0'), account_revenue) receipt.save() Receipt.confirm([receipt]) transaction.commit() with self.assertRaises(UserError): Receipt.post([receipt]) transaction.rollback() # Date before new_date = date - datetime.timedelta(days=1) receipt = self._get_receipt(company, bank, 'in', new_date, Decimal('99.0'), account_revenue) receipt.save() Receipt.confirm([receipt]) transaction.commit() with self.assertRaises(UserError): Receipt.post([receipt]) transaction.rollback() # Date OK new_date = date + datetime.timedelta(days=1) receipt = self._get_receipt(company, bank, 'in', new_date, Decimal('99.0'), account_revenue) receipt.save() Receipt.confirm([receipt]) Receipt.post([receipt])
def test_reference(self): 'Test reference' pool = Pool() Reference = pool.get('test.import_data.reference') transaction = Transaction() self.assertEqual(Reference.import_data(['reference'], [['test.import_data.reference.selection,Test']]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertEqual(Reference.import_data(['reference:id'], [['test.import_data.reference.selection,' 'tests.import_data_reference_selection_test']]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertEqual(Reference.import_data(['reference'], [['']]), 1) reference, = Reference.search([]) self.assertEqual(reference.reference, None) transaction.rollback() self.assertEqual(Reference.import_data(['reference'], [['test.import_data.reference.selection,Test'], ['test.import_data.reference.selection,Test']]), 2) for reference in Reference.search([]): self.assertEqual(reference.reference.__name__, 'test.import_data.reference.selection') transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference'], [['test.import_data.reference.selection,foo']]) transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference'], [['test.import_data.reference.selection,Duplicate']]) transaction.rollback() self.assertRaises(UserError, Reference.import_data, ['reference:id'], [['test.import_data.reference.selection,foo']]) transaction.rollback() self.assertRaises(Exception, Reference.import_data, ['reference:id'], [['test.import_data.reference.selection,test.foo']]) transaction.rollback()