From 4f03a5f136ab928ae74322bf1c34a1b6a6baf979 Mon Sep 17 00:00:00 2001
From: Julien Castiaux <juc@odoo.com>
Date: Wed, 11 Sep 2019 09:45:31 +0000
Subject: [PATCH] [FIX] *: remove old deprecated modules/functions
PEP-594 is deprecating a bunch of modules. As part of the cleanup, we
are also dealing with long deprecated modules, functions and aliases.
* `assert_` -> `assertTrue`
* `assertEquals` -> `assertEqual`
* `assertNotEquals` -> `assertNotEqual`
* `assertAlmostEquals` -> `assertAlmostEqual`
* `assertRaisesRegexp` -> `assertRaisesRegex`
* `assertRegexpMatches` -> `assertRegex`
* `base64.encodestring` -> `base64.encodebytes`
* `base64.decodestring` -> `base64.decodebytes`
* `inspect.getargspec` -> `inspect.signature`
* `inspect.formatargspec` -> `inspect.signature`
* `logging.warn` -> `logging.warning`
closes odoo/odoo#36863
Task: 2003936
Signed-off-by: Raphael Collet (rco) <rco@openerp.com>
---
.../account/models/account_bank_statement.py | 2 +-
addons/account/tests/account_test_classes.py | 2 +-
.../tests/test_account_journal_dashboard.py | 18 +-
addons/account/tests/test_fiscal_position.py | 2 +-
addons/account/tests/test_payment.py | 6 +-
addons/account/tests/test_reconciliation.py | 60 ++---
addons/base_import/models/base_import.py | 6 +-
.../models/base_import_module.py | 2 +-
addons/calendar/tests/test_calendar.py | 2 +-
addons/crm/tests/test_crm_pls.py | 4 +-
.../delivery/tests/test_packing_delivery.py | 4 +-
addons/hr_contract/tests/test_auto_status.py | 22 +-
addons/hr_expense/tests/test_expenses.py | 86 +++----
.../tests/test_expenses_mail_subjects.py | 52 ++--
.../tests/test_recruitment_process.py | 6 +-
addons/hr_timesheet/tests/test_timesheet.py | 38 +--
addons/l10n_be_edi/tests/test_ubl.py | 2 +-
addons/l10n_fr_fec/wizard/account_fr_fec.py | 2 +-
addons/l10n_it_edi/models/account_invoice.py | 2 +-
addons/l10n_it_edi/models/ir_mail_server.py | 2 +-
addons/maintenance/tests/test_maintenance.py | 4 +-
.../tests/test_maintenance_multicompany.py | 12 +-
addons/mrp/tests/test_procurement.py | 2 +-
addons/mrp/tests/test_stock.py | 8 +-
.../test_warehouse_multistep_manufacturing.py | 2 +-
addons/mrp/tests/test_workorder_operation.py | 12 +-
addons/mrp_account/tests/test_bom_price.py | 4 +-
.../tests/test_subcontracting.py | 68 +++---
addons/payment_stripe/models/payment.py | 2 +-
addons/pos_cache/models/pos_cache.py | 4 +-
.../tests/test_timesheet_holidays.py | 6 +-
.../tests/test_purchase_order_report.py | 8 +-
.../tests/test_purchase_mrp_flow.py | 38 +--
.../tests/test_create_picking.py | 4 +-
.../purchase_stock/tests/test_fifo_price.py | 14 +-
.../tests/test_move_cancel_propagation.py | 2 +-
.../tests/test_onchange_product.py | 8 +-
.../tests/test_stockvaluation.py | 56 ++---
addons/sale/tests/test_access_rights.py | 2 +-
addons/sale/tests/test_onchange.py | 6 +-
addons/sale/tests/test_reinvoice.py | 50 ++--
addons/sale/tests/test_sale_order.py | 10 +-
addons/sale/tests/test_sale_pricelist.py | 18 +-
addons/sale/tests/test_sale_refund.py | 222 +++++++++---------
addons/sale/tests/test_sale_to_invoice.py | 76 +++---
addons/sale_expense/tests/test_reinvoice.py | 54 ++---
addons/sale_mrp/tests/test_sale_mrp_flow.py | 120 +++++-----
.../sale_stock/tests/test_sale_order_dates.py | 6 +-
addons/sale_stock/tests/test_sale_stock.py | 12 +-
.../tests/test_sale_stock_lead_time.py | 8 +-
.../tests/test_project_billing.py | 2 +-
addons/sale_timesheet/tests/test_reinvoice.py | 58 ++---
addons/stock/tests/test_move2.py | 40 ++--
addons/stock/tests/test_packing.py | 28 +--
addons/stock/tests/test_proc_rule.py | 14 +-
addons/stock/tests/test_stock_flow.py | 36 +--
.../stock/tests/test_stock_location_search.py | 4 +-
.../stock_dropshipping/tests/test_dropship.py | 6 +-
.../survey/tests/test_certification_badge.py | 38 +--
.../tests/test_message_management.py | 4 +-
.../test_mail_full/tests/test_sms_composer.py | 8 +-
.../tests/test_controller_args.py | 24 +-
.../test_views_during_module_operation.py | 4 +-
addons/uom/tests/test_uom.py | 10 +-
addons/web/controllers/main.py | 2 +-
addons/web_editor/models/ir_qweb.py | 2 +-
addons/website/models/ir_http.py | 4 +-
addons/website/models/website.py | 13 +-
addons/website_form/controllers/main.py | 2 +-
.../tests/test_unsubscribe.py | 2 +-
.../tests/test_website_sale_pricelist.py | 6 +-
.../tests/test_website_sale_comparison.py | 6 +-
.../website_theme_install/tests/test_views.py | 12 +-
odoo/addons/base/models/ir_actions_report.py | 4 +-
odoo/addons/base/models/ir_model.py | 2 +-
odoo/addons/base/models/ir_ui_menu.py | 2 +-
odoo/addons/base/models/ir_ui_view.py | 2 +-
odoo/addons/base/models/res_users.py | 6 +-
odoo/addons/base/tests/test_acl.py | 14 +-
odoo/addons/base/tests/test_base.py | 18 +-
odoo/addons/base/tests/test_basecase.py | 2 +-
odoo/addons/base/tests/test_mail.py | 2 +-
odoo/addons/base/tests/test_mimetypes.py | 2 +-
odoo/addons/base/tests/test_osv.py | 12 +-
odoo/addons/base/tests/test_qweb.py | 4 +-
.../base/tests/test_res_partner_bank.py | 22 +-
odoo/addons/base/tests/test_translate.py | 40 ++--
.../base/wizard/base_export_language.py | 2 +-
.../base/wizard/base_import_language.py | 2 +-
.../tests/test_assetsbundle.py | 124 +++++-----
odoo/addons/test_lint/tests/test_pylint.py | 3 +-
.../tests/test_performance.py | 2 +-
.../tests/test_form_impl.py | 2 +-
.../tests/test_term_count.py | 6 +-
odoo/api.py | 4 +-
odoo/exceptions.py | 2 +-
odoo/http.py | 25 +-
odoo/models.py | 2 +-
odoo/modules/module.py | 2 +-
odoo/service/server.py | 2 +-
odoo/tools/cache.py | 18 +-
odoo/tools/convert.py | 4 +-
102 files changed, 911 insertions(+), 904 deletions(-)
diff --git a/addons/account/models/account_bank_statement.py b/addons/account/models/account_bank_statement.py
index 8ddf1b6000a1..e9fab1222923 100644
--- a/addons/account/models/account_bank_statement.py
+++ b/addons/account/models/account_bank_statement.py
@@ -300,7 +300,7 @@ class AccountBankStatement(models.Model):
self.env['ir.attachment'].create({
'name': statement.name and _("Bank Statement %s.pdf") % statement.name or _("Bank Statement.pdf"),
'type': 'binary',
- 'datas': base64.encodestring(content),
+ 'datas': base64.encodebytes(content),
'res_model': statement._name,
'res_id': statement.id
})
diff --git a/addons/account/tests/account_test_classes.py b/addons/account/tests/account_test_classes.py
index 3bf7d53f9702..00267faddd6a 100644
--- a/addons/account/tests/account_test_classes.py
+++ b/addons/account/tests/account_test_classes.py
@@ -17,7 +17,7 @@ class AccountingTestCase(HttpCase):
super(AccountingTestCase, self).setUp()
domain = [('company_id', '=', self.env.ref('base.main_company').id)]
if not self.env['account.account'].search_count(domain):
- _logger.warn('Test skipped because there is no chart of account defined ...')
+ _logger.warning('Test skipped because there is no chart of account defined ...')
self.skipTest("No Chart of account found")
def ensure_account_property(self, property_name):
diff --git a/addons/account/tests/test_account_journal_dashboard.py b/addons/account/tests/test_account_journal_dashboard.py
index ef7f8fad3a1c..0d6e88e30bcc 100644
--- a/addons/account/tests/test_account_journal_dashboard.py
+++ b/addons/account/tests/test_account_journal_dashboard.py
@@ -49,30 +49,30 @@ class TestAccountJournalDashboard(AccountTestUsers):
# Check Draft
dashboard_data = journal.get_journal_dashboard_datas()
- self.assertEquals(dashboard_data['number_draft'], 2)
+ self.assertEqual(dashboard_data['number_draft'], 2)
self.assertIn('68.42', dashboard_data['sum_draft'])
- self.assertEquals(dashboard_data['number_waiting'], 0)
+ self.assertEqual(dashboard_data['number_waiting'], 0)
self.assertIn('0.00', dashboard_data['sum_waiting'])
# Check Both
invoice.post()
dashboard_data = journal.get_journal_dashboard_datas()
- self.assertEquals(dashboard_data['number_draft'], 1)
+ self.assertEqual(dashboard_data['number_draft'], 1)
self.assertIn('-13.30', dashboard_data['sum_draft'])
- self.assertEquals(dashboard_data['number_waiting'], 1)
+ self.assertEqual(dashboard_data['number_waiting'], 1)
self.assertIn('81.72', dashboard_data['sum_waiting'])
# Check waiting payment
refund.post()
dashboard_data = journal.get_journal_dashboard_datas()
- self.assertEquals(dashboard_data['number_draft'], 0)
+ self.assertEqual(dashboard_data['number_draft'], 0)
self.assertIn('0.00', dashboard_data['sum_draft'])
- self.assertEquals(dashboard_data['number_waiting'], 2)
+ self.assertEqual(dashboard_data['number_waiting'], 2)
self.assertIn('68.42', dashboard_data['sum_waiting'])
# Check partial
@@ -96,13 +96,13 @@ class TestAccountJournalDashboard(AccountTestUsers):
refund.js_assign_outstanding_line(payment_move_line.id)
dashboard_data = journal.get_journal_dashboard_datas()
- self.assertEquals(dashboard_data['number_draft'], 0)
+ self.assertEqual(dashboard_data['number_draft'], 0)
self.assertIn('0.00', dashboard_data['sum_draft'])
- self.assertEquals(dashboard_data['number_waiting'], 2)
+ self.assertEqual(dashboard_data['number_waiting'], 2)
self.assertIn('78.42', dashboard_data['sum_waiting'])
with patch('odoo.fields.Date.today', patched_today):
dashboard_data = journal.get_journal_dashboard_datas()
- self.assertEquals(dashboard_data['number_late'], 2)
+ self.assertEqual(dashboard_data['number_late'], 2)
self.assertIn('78.42', dashboard_data['sum_late'])
diff --git a/addons/account/tests/test_fiscal_position.py b/addons/account/tests/test_fiscal_position.py
index f9d5ddd4b27d..4b19431806b8 100644
--- a/addons/account/tests/test_fiscal_position.py
+++ b/addons/account/tests/test_fiscal_position.py
@@ -58,7 +58,7 @@ class TestFiscalPosition(common.TransactionCase):
def test_10_fp_country(self):
def assert_fp(partner, expected_pos, message):
- self.assertEquals(
+ self.assertEqual(
self.fp.get_fiscal_position(partner.id),
expected_pos.id,
message)
diff --git a/addons/account/tests/test_payment.py b/addons/account/tests/test_payment.py
index ade019768eaf..eafe7b856ed0 100644
--- a/addons/account/tests/test_payment.py
+++ b/addons/account/tests/test_payment.py
@@ -88,7 +88,7 @@ class TestPayment(AccountingTestCase):
})
payment = self.payment_model.browse(register_payments.create_payments()['res_id'])
- self.assertAlmostEquals(payment.amount, 300)
+ self.assertAlmostEqual(payment.amount, 300)
self.assertEqual(payment.state, 'posted')
self.assertEqual(payment.state, 'posted')
self.assertEqual(inv_1.invoice_payment_state, 'paid')
@@ -161,7 +161,7 @@ class TestPayment(AccountingTestCase):
self.assertEqual(len(payment), 1)
self.assertEqual(payment.invoice_ids[0].id, inv_1.id)
- self.assertAlmostEquals(payment.amount, 550)
+ self.assertAlmostEqual(payment.amount, 550)
self.assertEqual(payment.payment_type, 'inbound')
self.assertEqual(payment.partner_id, self.partner_agrolait)
self.assertEqual(payment.partner_type, 'customer')
@@ -180,7 +180,7 @@ class TestPayment(AccountingTestCase):
self.assertEqual(len(payment), 1)
self.assertEqual(payment.invoice_ids[0].id, inv_2.id)
- self.assertAlmostEquals(payment.amount, 300)
+ self.assertAlmostEqual(payment.amount, 300)
self.assertEqual(payment.payment_type, 'outbound')
self.assertEqual(payment.partner_id, self.partner_china_exp)
self.assertEqual(payment.partner_type, 'supplier')
diff --git a/addons/account/tests/test_reconciliation.py b/addons/account/tests/test_reconciliation.py
index 94e5e69bee48..c23f4b048da4 100644
--- a/addons/account/tests/test_reconciliation.py
+++ b/addons/account/tests/test_reconciliation.py
@@ -370,11 +370,11 @@ class TestReconciliationExec(TestReconciliation):
])
# The invoice should be paid, as the payments totally cover its total
- self.assertEquals(move.invoice_payment_state, 'paid', 'The invoice should be paid by now')
+ self.assertEqual(move.invoice_payment_state, 'paid', 'The invoice should be paid by now')
self.assertTrue(receivable_line.reconciled, 'The invoice should be totally reconciled')
self.assertTrue(receivable_line.full_reconcile_id, 'The invoice should have a full reconcile number')
- self.assertEquals(receivable_line.amount_residual, 0, 'The invoice should be totally reconciled')
- self.assertEquals(receivable_line.amount_residual_currency, 0, 'The invoice should be totally reconciled')
+ self.assertEqual(receivable_line.amount_residual, 0, 'The invoice should be totally reconciled')
+ self.assertEqual(receivable_line.amount_residual_currency, 0, 'The invoice should be totally reconciled')
@unittest.skip('adapt to new accounting')
def test_balanced_exchanges_gain_loss(self):
@@ -440,7 +440,7 @@ class TestReconciliationExec(TestReconciliation):
])
# The invoice should be paid, as the payments totally cover its total
- self.assertEquals(invoice.state, 'paid', 'The invoice should be paid by now')
+ self.assertEqual(invoice.state, 'paid', 'The invoice should be paid by now')
reconcile = None
for payment in invoice.payment_ids:
reconcile = payment.reconcile_model_id
@@ -460,8 +460,8 @@ class TestReconciliationExec(TestReconciliation):
self.assertTrue(exchange_loss_line, 'There should be one move line of 0.01 EUR in credit')
# The journal items of the reconciliation should have their debit and credit total equal
# Besides, the total debit and total credit should be 60.61 EUR (2.00 USD)
- self.assertEquals(sum(res['debit'] for res in result.values()), 60.61)
- self.assertEquals(sum(res['credit'] for res in result.items()), 60.61)
+ self.assertEqual(sum(res['debit'] for res in result.values()), 60.61)
+ self.assertEqual(sum(res['credit'] for res in result.items()), 60.61)
counterpart_exchange_loss_line = None
for line in exchange_loss_line.move_id.line_id:
if line.account_id.id == self.account_fx_expense_id:
@@ -505,8 +505,8 @@ class TestReconciliationExec(TestReconciliation):
aml_recs.reconcile()
for aml in aml_recs:
self.assertTrue(aml.reconciled, 'The journal item should be totally reconciled')
- self.assertEquals(aml.amount_residual, 0, 'The journal item should be totally reconciled')
- self.assertEquals(aml.amount_residual_currency, 0, 'The journal item should be totally reconciled')
+ self.assertEqual(aml.amount_residual, 0, 'The journal item should be totally reconciled')
+ self.assertEqual(aml.amount_residual_currency, 0, 'The journal item should be totally reconciled')
move_list_vals = [
('2', 728.35, 795.05, self.currency_swiss_id),
@@ -522,8 +522,8 @@ class TestReconciliationExec(TestReconciliation):
aml_recs.reconcile(self.account_rsa, self.bank_journal_usd)
for aml in aml_recs:
self.assertTrue(aml.reconciled, 'The journal item should be totally reconciled')
- self.assertEquals(aml.amount_residual, 0, 'The journal item should be totally reconciled')
- self.assertEquals(aml.amount_residual_currency, 0, 'The journal item should be totally reconciled')
+ self.assertEqual(aml.amount_residual, 0, 'The journal item should be totally reconciled')
+ self.assertEqual(aml.amount_residual_currency, 0, 'The journal item should be totally reconciled')
def test_manual_reconcile_wizard_same_account(self):
move_ids = self.env['account.move']
@@ -582,7 +582,7 @@ class TestReconciliationExec(TestReconciliation):
}]
writeoff_line = account_move_line._create_writeoff(writeoff_vals)
(account_move_line + writeoff_line).reconcile()
- self.assertEquals(len(writeoff_line), 1, "The writeoff_line (balance_line) should have only one moves line")
+ self.assertEqual(len(writeoff_line), 1, "The writeoff_line (balance_line) should have only one moves line")
self.assertTrue(all(l.reconciled for l in writeoff_line), 'The balance lines should be totally reconciled')
self.assertTrue(all(l.reconciled for l in account_move_line), 'The move lines should be totally reconciled')
@@ -630,7 +630,7 @@ class TestReconciliationExec(TestReconciliation):
# Check that move lines associated to bank_statement are correct
bank_stmt_aml = self.env['account.move.line'].search([('statement_id', '=', bank_stmt.id)])
bank_stmt_aml |= bank_stmt_aml.mapped('move_id').mapped('line_ids')
- self.assertEquals(len(bank_stmt_aml), 4, "The bank statement should have 4 moves lines")
+ self.assertEqual(len(bank_stmt_aml), 4, "The bank statement should have 4 moves lines")
lines = {
self.account_usd.id: [
{'debit': 3.27, 'credit': 0.0, 'amount_currency': 5, 'currency_id': self.currency_usd_id},
@@ -655,10 +655,10 @@ class TestReconciliationExec(TestReconciliation):
line = line[0]
else:
line = line[1]
- self.assertEquals(round(aml.debit, 2), line['debit'])
- self.assertEquals(round(aml.credit, 2), line['credit'])
- self.assertEquals(round(aml.amount_currency, 2), line['amount_currency'])
- self.assertEquals(aml.currency_id.id, line['currency_id'])
+ self.assertEqual(round(aml.debit, 2), line['debit'])
+ self.assertEqual(round(aml.credit, 2), line['credit'])
+ self.assertEqual(round(aml.amount_currency, 2), line['amount_currency'])
+ self.assertEqual(aml.currency_id.id, line['currency_id'])
def test_partial_reconcile_currencies_01(self):
# client Account (payable, rsa)
@@ -809,19 +809,19 @@ class TestReconciliationExec(TestReconciliation):
credit_aml = payment.move_line_ids.filtered('credit')
# Check residual before assignation
- self.assertAlmostEquals(inv1.amount_residual, 10)
- self.assertAlmostEquals(inv2.amount_residual, 20)
+ self.assertAlmostEqual(inv1.amount_residual, 10)
+ self.assertAlmostEqual(inv2.amount_residual, 20)
# Assign credit and residual
inv1.js_assign_outstanding_line(credit_aml.id)
inv2.js_assign_outstanding_line(credit_aml.id)
- self.assertAlmostEquals(inv1.amount_residual, 0)
- self.assertAlmostEquals(inv2.amount_residual, 0)
+ self.assertAlmostEqual(inv1.amount_residual, 0)
+ self.assertAlmostEqual(inv2.amount_residual, 0)
# Unreconcile one invoice at a time and check residual
credit_aml.remove_move_reconcile()
- self.assertAlmostEquals(inv1.amount_residual, 10)
- self.assertAlmostEquals(inv2.amount_residual, 20)
+ self.assertAlmostEqual(inv1.amount_residual, 10)
+ self.assertAlmostEqual(inv2.amount_residual, 20)
def test_unreconcile_exchange(self):
# Use case:
@@ -860,16 +860,16 @@ class TestReconciliationExec(TestReconciliation):
credit_aml = payment.move_line_ids.filtered('credit')
# Check residual before assignation
- self.assertAlmostEquals(inv.amount_residual, 111)
+ self.assertAlmostEqual(inv.amount_residual, 111)
# Assign credit, check exchange move and residual
inv.js_assign_outstanding_line(credit_aml.id)
self.assertEqual(len(payment.move_line_ids.mapped('full_reconcile_id').exchange_move_id), 1)
- self.assertAlmostEquals(inv.amount_residual, 0)
+ self.assertAlmostEqual(inv.amount_residual, 0)
# Unreconcile invoice and check residual
credit_aml.with_context(invoice_id=inv.id).remove_move_reconcile()
- self.assertAlmostEquals(inv.amount_residual, 111)
+ self.assertAlmostEqual(inv.amount_residual, 111)
def test_revert_payment_and_reconcile(self):
payment = self.env['account.payment'].create({
@@ -1224,14 +1224,14 @@ class TestReconciliationExec(TestReconciliation):
self.env["account.reconciliation.widget"].process_move_lines(data_for_reconciliation)
self.assertTrue(inv1_receivable.full_reconcile_id.exists())
- self.assertEquals(inv1_receivable.full_reconcile_id, inv2_receivable.full_reconcile_id)
- self.assertEquals(inv1_receivable.full_reconcile_id, pay_receivable.full_reconcile_id)
+ self.assertEqual(inv1_receivable.full_reconcile_id, inv2_receivable.full_reconcile_id)
+ self.assertEqual(inv1_receivable.full_reconcile_id, pay_receivable.full_reconcile_id)
self.assertTrue(all(l.reconciled for l in inv1_receivable))
self.assertTrue(all(l.reconciled for l in inv2_receivable))
- self.assertEquals(inv1.invoice_payment_state, 'paid')
- self.assertEquals(inv2.invoice_payment_state, 'paid')
+ self.assertEqual(inv1.invoice_payment_state, 'paid')
+ self.assertEqual(inv2.invoice_payment_state, 'paid')
def test_multiple_term_reconciliation_opw_1906665(self):
'''Test that when registering a payment to an invoice with multiple
@@ -2145,4 +2145,4 @@ class TestReconciliationExec(TestReconciliation):
}])
writeoff_line = self.env['account.move.line'].search([('name', '=', 'writeoff')])
- self.assertEquals(writeoff_line.credit, 15.0)
+ self.assertEqual(writeoff_line.credit, 15.0)
diff --git a/addons/base_import/models/base_import.py b/addons/base_import/models/base_import.py
index 9fc3feff1bd8..9094bbabf16b 100644
--- a/addons/base_import/models/base_import.py
+++ b/addons/base_import/models/base_import.py
@@ -236,7 +236,7 @@ class Import(models.TransientModel):
try:
return getattr(self, '_read_' + file_extension)(options)
except Exception:
- _logger.warn("Failed to read file '%s' (transient id %d) using guessed mimetype %s", self.file_name or '<unknown>', self.id, mimetype)
+ _logger.warning("Failed to read file '%s' (transient id %d) using guessed mimetype %s", self.file_name or '<unknown>', self.id, mimetype)
# try reading with user-provided mimetype
(file_extension, handler, req) = FILE_TYPE_DICT.get(self.file_type, (None, None, None))
@@ -244,7 +244,7 @@ class Import(models.TransientModel):
try:
return getattr(self, '_read_' + file_extension)(options)
except Exception:
- _logger.warn("Failed to read file '%s' (transient id %d) using user-provided mimetype %s", self.file_name or '<unknown>', self.id, self.file_type)
+ _logger.warning("Failed to read file '%s' (transient id %d) using user-provided mimetype %s", self.file_name or '<unknown>', self.id, self.file_type)
# fallback on file extensions as mime types can be unreliable (e.g.
# software setting incorrect mime types, or non-installed software
@@ -255,7 +255,7 @@ class Import(models.TransientModel):
try:
return getattr(self, '_read_' + ext[1:])(options)
except Exception:
- _logger.warn("Failed to read file '%s' (transient id %s) using file extension", self.file_name, self.id)
+ _logger.warning("Failed to read file '%s' (transient id %s) using file extension", self.file_name, self.id)
if req:
raise ImportError(_("Unable to load \"{extension}\" file: requires Python module \"{modname}\"").format(extension=file_extension, modname=req))
diff --git a/addons/base_import_module/models/base_import_module.py b/addons/base_import_module/models/base_import_module.py
index 84510330ab64..985f3e45a7bf 100644
--- a/addons/base_import_module/models/base_import_module.py
+++ b/addons/base_import_module/models/base_import_module.py
@@ -17,7 +17,7 @@ class BaseImportModule(models.TransientModel):
def import_module(self):
self.ensure_one()
IrModule = self.env['ir.module.module']
- zip_data = base64.decodestring(self.module_file)
+ zip_data = base64.decodebytes(self.module_file)
fp = BytesIO()
fp.write(zip_data)
res = IrModule.import_zipfile(fp, force=self.force)
diff --git a/addons/calendar/tests/test_calendar.py b/addons/calendar/tests/test_calendar.py
index 6b7d7f1a550a..ba7d3e840a28 100644
--- a/addons/calendar/tests/test_calendar.py
+++ b/addons/calendar/tests/test_calendar.py
@@ -159,7 +159,7 @@ class TestCalendar(TransactionCase):
(str(m.start_datetime), str(m.stop_datetime)),
('2017-07-12 14:30:00', u'2017-07-12 15:00:00'),
)
- self.assertEquals(
+ self.assertEqual(
(str(records.start_datetime), str(records.stop_datetime)),
(u'2017-07-10 15:30:00', u'2017-07-10 16:00:00'),
)
diff --git a/addons/crm/tests/test_crm_pls.py b/addons/crm/tests/test_crm_pls.py
index ef3a7cdba15d..304bdce88681 100644
--- a/addons/crm/tests/test_crm_pls.py
+++ b/addons/crm/tests/test_crm_pls.py
@@ -78,5 +78,5 @@ class TestCRMPLS(TransactionCase):
# As the cron is computing and writing in SQL queries, we need to invalidate the cache
leads.invalidate_cache()
- self.assertEquals(tools.float_compare(leads[3].automated_probability, 33.49, 2), 0)
- self.assertEquals(tools.float_compare(leads[7].automated_probability, 7.74, 2), 0)
+ self.assertEqual(tools.float_compare(leads[3].automated_probability, 33.49, 2), 0)
+ self.assertEqual(tools.float_compare(leads[7].automated_probability, 7.74, 2), 0)
diff --git a/addons/delivery/tests/test_packing_delivery.py b/addons/delivery/tests/test_packing_delivery.py
index 84e694a530dc..89630390cd49 100644
--- a/addons/delivery/tests/test_packing_delivery.py
+++ b/addons/delivery/tests/test_packing_delivery.py
@@ -66,9 +66,9 @@ class TestPacking(TestPacking):
pack_action_model = pack_action['res_model']
# We make sure the correct action was returned
- self.assertEquals(pack_action_model, 'choose.delivery.package')
+ self.assertEqual(pack_action_model, 'choose.delivery.package')
# We instanciate the wizard with the context of the action and check that the
# default weight was set.
pack_wiz = self.env['choose.delivery.package'].with_context(pack_action_ctx).create({})
- self.assertEquals(pack_wiz.shipping_weight, 13.5)
+ self.assertEqual(pack_wiz.shipping_weight, 13.5)
diff --git a/addons/hr_contract/tests/test_auto_status.py b/addons/hr_contract/tests/test_auto_status.py
index fcff8621bb90..847e6fb9ca01 100644
--- a/addons/hr_contract/tests/test_auto_status.py
+++ b/addons/hr_contract/tests/test_auto_status.py
@@ -13,7 +13,7 @@ class TestHrContracts(TestContractBase):
self.test_contract = dict(name='Test', wage=1, employee_id=self.employee.id, state='open')
def test_employee_contractwarning(self):
- self.assertEquals(self.employee.contract_warning, True)
+ self.assertEqual(self.employee.contract_warning, True)
def apply_cron(self):
self.env.ref('hr_contract.ir_cron_data_contract_update_state').method_direct_trigger()
@@ -22,15 +22,15 @@ class TestHrContracts(TestContractBase):
self.test_contract.update(dict(date_end=datetime.now() + relativedelta(days=100)))
self.contract = self.contracts.create(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'open')
- self.assertEquals(self.contract.kanban_state, 'normal')
- self.assertEquals(self.employee.contract_warning, False)
+ self.assertEqual(self.contract.state, 'open')
+ self.assertEqual(self.contract.kanban_state, 'normal')
+ self.assertEqual(self.employee.contract_warning, False)
self.test_contract.update(dict(date_end=datetime.now() + relativedelta(days=5)))
self.contract.write(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'open')
- self.assertEquals(self.contract.kanban_state, 'blocked')
+ self.assertEqual(self.contract.state, 'open')
+ self.assertEqual(self.contract.kanban_state, 'blocked')
self.test_contract.update({
'date_start': datetime.now() + relativedelta(days=-50),
@@ -40,15 +40,15 @@ class TestHrContracts(TestContractBase):
})
self.contract.write(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'close')
+ self.assertEqual(self.contract.state, 'close')
def test_contract_pending_visa_expire(self):
self.employee.visa_expire = date.today() + relativedelta(days=30)
self.test_contract.update(dict(date_end=False))
self.contract = self.contracts.create(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'open')
- self.assertEquals(self.contract.kanban_state, 'blocked')
+ self.assertEqual(self.contract.state, 'open')
+ self.assertEqual(self.contract.kanban_state, 'blocked')
self.employee.visa_expire = date.today() + relativedelta(days=-5)
self.test_contract.update({
@@ -58,10 +58,10 @@ class TestHrContracts(TestContractBase):
})
self.contract.write(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'close')
+ self.assertEqual(self.contract.state, 'close')
def test_contract_start_date(self):
self.test_contract.update(dict(date_start=datetime.now(), state='draft', kanban_state='done'))
self.contract = self.contracts.create(self.test_contract)
self.apply_cron()
- self.assertEquals(self.contract.state, 'open')
+ self.assertEqual(self.contract.state, 'open')
diff --git a/addons/hr_expense/tests/test_expenses.py b/addons/hr_expense/tests/test_expenses.py
index c4958f411087..809ed23079cb 100644
--- a/addons/hr_expense/tests/test_expenses.py
+++ b/addons/hr_expense/tests/test_expenses.py
@@ -44,39 +44,39 @@ class TestAccountEntry(TestExpenseCommon):
})
expense_line._onchange_product_id()
# State should default to draft
- self.assertEquals(expense.state, 'draft', 'Expense should be created in Draft state')
+ self.assertEqual(expense.state, 'draft', 'Expense should be created in Draft state')
# Submitted to Manager
expense.action_submit_sheet()
- self.assertEquals(expense.state, 'submit', 'Expense is not in Reported state')
+ self.assertEqual(expense.state, 'submit', 'Expense is not in Reported state')
# Approve
expense.approve_expense_sheets()
- self.assertEquals(expense.state, 'approve', 'Expense is not in Approved state')
+ self.assertEqual(expense.state, 'approve', 'Expense is not in Approved state')
# Create Expense Entries
expense.action_sheet_move_create()
- self.assertEquals(expense.state, 'post', 'Expense is not in Waiting Payment state')
+ self.assertEqual(expense.state, 'post', 'Expense is not in Waiting Payment state')
self.assertTrue(expense.account_move_id.id, 'Expense Journal Entry is not created')
# [(line.debit, line.credit, line.tax_line_id.id) for line in self.expense.expense_line_ids.account_move_id.line_ids]
# should git this result [(0.0, 700.0, False), (63.64, 0.0, 179), (636.36, 0.0, False)]
for line in expense.account_move_id.line_ids:
if line.credit:
- self.assertAlmostEquals(line.credit, 700.00)
- self.assertEquals(len(line.analytic_line_ids), 0, "The credit move line should not have analytic lines")
+ self.assertAlmostEqual(line.credit, 700.00)
+ self.assertEqual(len(line.analytic_line_ids), 0, "The credit move line should not have analytic lines")
self.assertFalse(line.product_id, "Product of credit move line should be false")
else:
if not line.tax_line_id == self.tax:
- self.assertAlmostEquals(line.debit, 636.36)
- self.assertEquals(len(line.analytic_line_ids), 1, "The debit move line should have 1 analytic lines")
- self.assertEquals(line.product_id, self.product_expense, "Product of debit move line should be the one from the expense")
+ self.assertAlmostEqual(line.debit, 636.36)
+ self.assertEqual(len(line.analytic_line_ids), 1, "The debit move line should have 1 analytic lines")
+ self.assertEqual(line.product_id, self.product_expense, "Product of debit move line should be the one from the expense")
else:
- self.assertAlmostEquals(line.debit, 63.64)
- self.assertEquals(len(line.analytic_line_ids), 0, "The tax move line should not have analytic lines")
+ self.assertAlmostEqual(line.debit, 63.64)
+ self.assertEqual(len(line.analytic_line_ids), 0, "The tax move line should not have analytic lines")
self.assertFalse(line.product_id, "Product of tax move line should be false")
- self.assertEquals(self.analytic_account.line_ids, expense.account_move_id.mapped('line_ids.analytic_line_ids'))
- self.assertEquals(len(self.analytic_account.line_ids), 1, "Analytic Account should have only one line")
- self.assertAlmostEquals(self.analytic_account.line_ids[0].amount, -636.36, "Amount on the only AAL is wrong")
- self.assertEquals(self.analytic_account.line_ids[0].product_id, self.product_expense, "Product of AAL should be the one from the expense")
+ self.assertEqual(self.analytic_account.line_ids, expense.account_move_id.mapped('line_ids.analytic_line_ids'))
+ self.assertEqual(len(self.analytic_account.line_ids), 1, "Analytic Account should have only one line")
+ self.assertAlmostEqual(self.analytic_account.line_ids[0].amount, -636.36, "Amount on the only AAL is wrong")
+ self.assertEqual(self.analytic_account.line_ids[0].product_id, self.product_expense, "Product of AAL should be the one from the expense")
def test_account_entry_multi_currency(self):
""" Checking accounting move entries and analytic entries when submitting expense. With
@@ -108,42 +108,42 @@ class TestAccountEntry(TestExpenseCommon):
})
expense_line._onchange_product_id()
# State should default to draft
- self.assertEquals(expense.state, 'draft', 'Expense should be created in Draft state')
+ self.assertEqual(expense.state, 'draft', 'Expense should be created in Draft state')
# Submitted to Manager
expense.action_submit_sheet()
- self.assertEquals(expense.state, 'submit', 'Expense is not in Reported state')
+ self.assertEqual(expense.state, 'submit', 'Expense is not in Reported state')
# Approve
expense.approve_expense_sheets()
- self.assertEquals(expense.state, 'approve', 'Expense is not in Approved state')
+ self.assertEqual(expense.state, 'approve', 'Expense is not in Approved state')
# Create Expense Entries
expense.action_sheet_move_create()
- self.assertEquals(expense.state, 'post', 'Expense is not in Waiting Payment state')
+ self.assertEqual(expense.state, 'post', 'Expense is not in Waiting Payment state')
self.assertTrue(expense.account_move_id.id, 'Expense Journal Entry is not created')
# Should get this result [(0.0, 350.0, -700.0), (318.18, 0.0, 636.36), (31.82, 0.0, 63.64)]
for line in expense.account_move_id.line_ids:
if line.credit:
- self.assertAlmostEquals(line.credit, 350.0)
- self.assertAlmostEquals(line.amount_currency, -700.0)
- self.assertEquals(len(line.analytic_line_ids), 0, "The credit move line should not have analytic lines")
+ self.assertAlmostEqual(line.credit, 350.0)
+ self.assertAlmostEqual(line.amount_currency, -700.0)
+ self.assertEqual(len(line.analytic_line_ids), 0, "The credit move line should not have analytic lines")
self.assertFalse(line.product_id, "Product of credit move line should be false")
else:
if not line.tax_line_id == self.tax:
- self.assertAlmostEquals(line.debit, 318.18)
- self.assertAlmostEquals(line.amount_currency, 636.36)
- self.assertEquals(len(line.analytic_line_ids), 1, "The debit move line should have 1 analytic lines")
- self.assertEquals(line.product_id, self.product_expense, "Product of debit move line should be the one from the expense")
+ self.assertAlmostEqual(line.debit, 318.18)
+ self.assertAlmostEqual(line.amount_currency, 636.36)
+ self.assertEqual(len(line.analytic_line_ids), 1, "The debit move line should have 1 analytic lines")
+ self.assertEqual(line.product_id, self.product_expense, "Product of debit move line should be the one from the expense")
else:
- self.assertAlmostEquals(line.debit, 31.82)
- self.assertAlmostEquals(line.amount_currency, 63.64)
- self.assertEquals(len(line.analytic_line_ids), 0, "The tax move line should not have analytic lines")
+ self.assertAlmostEqual(line.debit, 31.82)
+ self.assertAlmostEqual(line.amount_currency, 63.64)
+ self.assertEqual(len(line.analytic_line_ids), 0, "The tax move line should not have analytic lines")
self.assertFalse(line.product_id, "Product of tax move line should be false")
- self.assertEquals(self.analytic_account.line_ids, expense.account_move_id.mapped('line_ids.analytic_line_ids'))
- self.assertEquals(len(self.analytic_account.line_ids), 1, "Analytic Account should have only one line")
- self.assertAlmostEquals(self.analytic_account.line_ids[0].amount, -318.18, "Amount on the only AAL is wrong")
- self.assertAlmostEquals(self.analytic_account.line_ids[0].currency_id, self.env.company.currency_id, "Currency on the only AAL is wrong")
- self.assertEquals(self.analytic_account.line_ids[0].product_id, self.product_expense, "Product of AAL should be the one from the expense")
+ self.assertEqual(self.analytic_account.line_ids, expense.account_move_id.mapped('line_ids.analytic_line_ids'))
+ self.assertEqual(len(self.analytic_account.line_ids), 1, "Analytic Account should have only one line")
+ self.assertAlmostEqual(self.analytic_account.line_ids[0].amount, -318.18, "Amount on the only AAL is wrong")
+ self.assertAlmostEqual(self.analytic_account.line_ids[0].currency_id, self.env.company.currency_id, "Currency on the only AAL is wrong")
+ self.assertEqual(self.analytic_account.line_ids[0].product_id, self.product_expense, "Product of AAL should be the one from the expense")
def test_expense_from_email(self):
user_demo = self.env.ref('base.user_demo')
@@ -161,9 +161,9 @@ class TestAccountEntry(TestExpenseCommon):
expense = self.env['hr.expense'].message_new(message_parsed)
air_ticket = self.env.ref("hr_expense.air_ticket")
- self.assertEquals(expense.product_id, air_ticket)
- self.assertEquals(expense.tax_ids.ids, [])
- self.assertEquals(expense.total_amount, 9876.0)
+ self.assertEqual(expense.product_id, air_ticket)
+ self.assertEqual(expense.tax_ids.ids, [])
+ self.assertEqual(expense.total_amount, 9876.0)
self.assertTrue(expense.employee_id in user_demo.employee_ids)
def test_expense_from_email_without_product(self):
@@ -183,8 +183,8 @@ class TestAccountEntry(TestExpenseCommon):
air_ticket = self.env.ref("hr_expense.air_ticket")
self.assertFalse(expense.product_id, "No product should be linked")
- self.assertEquals(expense.tax_ids.ids, [])
- self.assertEquals(expense.total_amount, 9876.0)
+ self.assertEqual(expense.tax_ids.ids, [])
+ self.assertEqual(expense.total_amount, 9876.0)
self.assertTrue(expense.employee_id in user_demo.employee_ids)
def test_partial_payment_multiexpense(self):
@@ -222,7 +222,7 @@ class TestAccountEntry(TestExpenseCommon):
exp_move_lines = expense.account_move_id.line_ids
payable_move_lines = exp_move_lines.filtered(lambda l: l.account_id.internal_type == 'payable')
- self.assertEquals(len(payable_move_lines), 2)
+ self.assertEqual(len(payable_move_lines), 2)
WizardRegister = self.env["hr.expense.sheet.register.payment.wizard"].with_context(
active_model=expense._name, active_id=expense.id, active_ids=expense.ids
@@ -237,7 +237,7 @@ class TestAccountEntry(TestExpenseCommon):
exp_move_lines = expense.account_move_id.line_ids
payable_move_lines = exp_move_lines.filtered(lambda l: l.account_id.internal_type == 'payable')
- self.assertEquals(len(payable_move_lines.filtered(lambda l: l.reconciled)), 1)
+ self.assertEqual(len(payable_move_lines.filtered(lambda l: l.reconciled)), 1)
register_pay2 = WizardRegister.create({
'journal_id': bank_journal.id,
@@ -247,10 +247,10 @@ class TestAccountEntry(TestExpenseCommon):
register_pay2.expense_post_payment()
exp_move_lines = expense.account_move_id.line_ids
payable_move_lines = exp_move_lines.filtered(lambda l: l.account_id.internal_type == 'payable')
- self.assertEquals(len(payable_move_lines.filtered(lambda l: l.reconciled)), 2)
+ self.assertEqual(len(payable_move_lines.filtered(lambda l: l.reconciled)), 2)
full_reconcile = payable_move_lines.mapped('full_reconcile_id')
- self.assertEquals(len(full_reconcile), 1)
+ self.assertEqual(len(full_reconcile), 1)
class TestExpenseRights(TestExpenseCommon):
diff --git a/addons/hr_expense/tests/test_expenses_mail_subjects.py b/addons/hr_expense/tests/test_expenses_mail_subjects.py
index 134726e32cf7..0500050a39e6 100644
--- a/addons/hr_expense/tests/test_expenses_mail_subjects.py
+++ b/addons/hr_expense/tests/test_expenses_mail_subjects.py
@@ -31,16 +31,16 @@ class TestExpenseSubject(TestExpenseCommon):
subject = 'EXP-PHONE bar %s1205.91 electro wizard' % (company_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency)
- self.assertEquals(expense_description, 'bar electro wizard', "Should be remove price and product from subject")
- self.assertAlmostEquals(price, 1205.91, "Price is not fetched correctly")
- self.assertEquals(currency_id, company_currency, "Should fetch currency correctly")
- self.assertEquals(product, self.product_expense, "Should fetch product correctly")
+ self.assertEqual(expense_description, 'bar electro wizard', "Should be remove price and product from subject")
+ self.assertAlmostEqual(price, 1205.91, "Price is not fetched correctly")
+ self.assertEqual(currency_id, company_currency, "Should fetch currency correctly")
+ self.assertEqual(product, self.product_expense, "Should fetch product correctly")
# subject having other currency then company currency, it should ignore other currency then company currency
subject = 'foo bar %s1406.91 royal giant' % (alternate_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency)
- self.assertEquals(expense_description, 'foo bar %s royal giant' % (alternate_currency.symbol,), "Should be remove price and product from subject but not currency symbol")
- self.assertEquals(currency_id, company_currency, "Should fetch currency correctly")
+ self.assertEqual(expense_description, 'foo bar %s royal giant' % (alternate_currency.symbol,), "Should be remove price and product from subject but not currency symbol")
+ self.assertEqual(currency_id, company_currency, "Should fetch currency correctly")
# With Multi currency access
group_multi_currency = self.env.ref('base.group_multi_currency')
@@ -50,55 +50,55 @@ class TestExpenseSubject(TestExpenseCommon):
subject = 'EXP-PHONE foo bar %s2205.92 elite barbarians' % (company_currency.symbol,) # with product code at start
product, price, currency_id, expense_description = parse_subject(subject, company_currency)
- self.assertEquals(expense_description, 'foo bar elite barbarians', "Should be remove price and product from subject")
- self.assertAlmostEquals(price, 2205.92, "Price is not fetched correctly")
- self.assertEquals(currency_id, company_currency, "Should fetch currency correctly")
- self.assertEquals(product, self.product_expense, "Should fetch product correctly")
+ self.assertEqual(expense_description, 'foo bar elite barbarians', "Should be remove price and product from subject")
+ self.assertAlmostEqual(price, 2205.92, "Price is not fetched correctly")
+ self.assertEqual(currency_id, company_currency, "Should fetch currency correctly")
+ self.assertEqual(product, self.product_expense, "Should fetch product correctly")
# subject having other currency then company currency, it should accept other currency because multi currency is activated
subject = 'EXP-PHONE %s2510.90 chhota bheem' % (alternate_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertEquals(expense_description, 'chhota bheem', "Should be remove price and product from subject but not currency symbol")
- self.assertAlmostEquals(price, 2510.90, "Price is not fetched correctly")
- self.assertEquals(currency_id, alternate_currency, "Should fetch currency correctly")
- self.assertEquals(product, self.product_expense, "Should fetch product correctly")
+ self.assertEqual(expense_description, 'chhota bheem', "Should be remove price and product from subject but not currency symbol")
+ self.assertAlmostEqual(price, 2510.90, "Price is not fetched correctly")
+ self.assertEqual(currency_id, alternate_currency, "Should fetch currency correctly")
+ self.assertEqual(product, self.product_expense, "Should fetch product correctly")
# subject without product and currency, should take company currency and default product
subject = 'foo bar 109.96 spear goblins'
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertEquals(expense_description, 'foo bar spear goblins', "Should remove price")
- self.assertAlmostEquals(price, 109.96, "Price is not fetched correctly")
+ self.assertEqual(expense_description, 'foo bar spear goblins', "Should remove price")
+ self.assertAlmostEqual(price, 109.96, "Price is not fetched correctly")
self.assertIn(currency_id, company_currency | alternate_currency, "Should fetch company currency")
self.assertFalse(product, "Should not have parsed any product")
# subject with currency symbol at end
subject = 'EXP-PHONE foo bar 2910.94%s inferno dragon' % (company_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertEquals(expense_description, 'foo bar inferno dragon', "Should be remove price and product from subject")
- self.assertAlmostEquals(price, 2910.94, "Price is not fetched correctly")
- self.assertEquals(currency_id, company_currency, "Should fetch currency correctly")
- self.assertEquals(product, self.product_expense, "Should fetch product correctly")
+ self.assertEqual(expense_description, 'foo bar inferno dragon', "Should be remove price and product from subject")
+ self.assertAlmostEqual(price, 2910.94, "Price is not fetched correctly")
+ self.assertEqual(currency_id, company_currency, "Should fetch currency correctly")
+ self.assertEqual(product, self.product_expense, "Should fetch product correctly")
# subject with no amount and product
subject = 'foo bar mega knight'
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertEquals(expense_description, 'foo bar mega knight', "Should be same as subject")
- self.assertAlmostEquals(price, 0.0, "Price is not fetched correctly")
+ self.assertEqual(expense_description, 'foo bar mega knight', "Should be same as subject")
+ self.assertAlmostEqual(price, 0.0, "Price is not fetched correctly")
self.assertIn(currency_id, company_currency | alternate_currency, "Should fetch currency correctly")
self.assertFalse(product, "Should fetch product correctly")
# price with a comma
subject = 'foo bar 291,56%s mega knight' % (company_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertAlmostEquals(price, 291.56, "Price is not fetched correctly")
- self.assertEquals(currency_id, company_currency, "Should fetch currency correctly")
+ self.assertAlmostEqual(price, 291.56, "Price is not fetched correctly")
+ self.assertEqual(currency_id, company_currency, "Should fetch currency correctly")
# price without decimals
subject = 'foo bar 291%s mega knight' % (company_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
- self.assertAlmostEquals(price, 291.0, "Price is not fetched correctly")
+ self.assertAlmostEqual(price, 291.0, "Price is not fetched correctly")
subject = 'EXP-PHONE 2 foo bar 291.5%s mega knight' % (company_currency.symbol,)
product, price, currency_id, expense_description = parse_subject(subject, company_currency | alternate_currency)
print(price)
- self.assertAlmostEquals(price, 291.5, "Price is not fetched correctly")
+ self.assertAlmostEqual(price, 291.5, "Price is not fetched correctly")
diff --git a/addons/hr_recruitment/tests/test_recruitment_process.py b/addons/hr_recruitment/tests/test_recruitment_process.py
index 03f411bb371a..0eebc5fe5f8f 100644
--- a/addons/hr_recruitment/tests/test_recruitment_process.py
+++ b/addons/hr_recruitment/tests/test_recruitment_process.py
@@ -33,13 +33,13 @@ class TestRecruitmentProcess(common.TransactionCase):
('name', '=', 'resume.pdf'),
('res_model', '=', self.env['hr.applicant']._name),
('res_id', '=', applicant.id)])
- self.assertEquals(applicant.name, 'Application for the post of Jr.application Programmer.', 'Applicant name does not match.')
- self.assertEquals(applicant.stage_id, self.env.ref('hr_recruitment.stage_job1'),
+ self.assertEqual(applicant.name, 'Application for the post of Jr.application Programmer.', 'Applicant name does not match.')
+ self.assertEqual(applicant.stage_id, self.env.ref('hr_recruitment.stage_job1'),
"Stage should be 'Initial qualification' and is '%s'." % (applicant.stage_id.name))
self.assertTrue(resume_ids, 'Resume is not attached.')
# I assign the Job position to the applicant
applicant.write({'job_id': self.env.ref('hr.job_developer').id})
# I schedule meeting with applicant for interview.
applicant_meeting = applicant.action_makeMeeting()
- self.assertEquals(applicant_meeting['context']['default_name'], 'Application for the post of Jr.application Programmer.',
+ self.assertEqual(applicant_meeting['context']['default_name'], 'Application for the post of Jr.application Programmer.',
'Applicant name does not match.')
diff --git a/addons/hr_timesheet/tests/test_timesheet.py b/addons/hr_timesheet/tests/test_timesheet.py
index c2bfab9e8bdc..fed0c53b953f 100644
--- a/addons/hr_timesheet/tests/test_timesheet.py
+++ b/addons/hr_timesheet/tests/test_timesheet.py
@@ -89,10 +89,10 @@ class TestTimesheet(TestCommonTimesheet):
'name': 'my first timesheet',
'unit_amount': 4,
})
- self.assertEquals(timesheet1.account_id, self.project_customer.analytic_account_id, 'Analytic account should be the same as the project')
- self.assertEquals(timesheet1.employee_id, self.empl_employee, 'Employee should be the one of the current user')
- self.assertEquals(timesheet1.partner_id, self.task1.partner_id, 'Customer of task should be the same of the one set on new timesheet')
- self.assertEquals(timesheet1.product_uom_id, timesheet_uom, "The UoM of the timesheet should be the one set on the company of the analytic account.")
+ self.assertEqual(timesheet1.account_id, self.project_customer.analytic_account_id, 'Analytic account should be the same as the project')
+ self.assertEqual(timesheet1.employee_id, self.empl_employee, 'Employee should be the one of the current user')
+ self.assertEqual(timesheet1.partner_id, self.task1.partner_id, 'Customer of task should be the same of the one set on new timesheet')
+ self.assertEqual(timesheet1.product_uom_id, timesheet_uom, "The UoM of the timesheet should be the one set on the company of the analytic account.")
# employee 1 cannot log timesheet for employee 2
with self.assertRaises(AccessError):
@@ -113,8 +113,8 @@ class TestTimesheet(TestCommonTimesheet):
'employee_id': self.empl_employee2.id,
})
timesheet3._onchange_employee_id()
- self.assertEquals(timesheet3.user_id, self.user_employee2, 'Timesheet user should be the one linked to the given employee')
- self.assertEquals(timesheet3.product_uom_id, timesheet_uom, "The UoM of the timesheet 3 should be the one set on the company of the analytic account.")
+ self.assertEqual(timesheet3.user_id, self.user_employee2, 'Timesheet user should be the one linked to the given employee')
+ self.assertEqual(timesheet3.product_uom_id, timesheet_uom, "The UoM of the timesheet 3 should be the one set on the company of the analytic account.")
# employee 1 log some timesheet on project (no task)
timesheet4 = Timesheet.with_user(self.user_employee).create({
@@ -122,7 +122,7 @@ class TestTimesheet(TestCommonTimesheet):
'name': 'my first timesheet',
'unit_amount': 4,
})
- self.assertEquals(timesheet4.partner_id, self.project_customer.partner_id, 'Customer of new timesheet should be the same of the one set project (since no task on timesheet)')
+ self.assertEqual(timesheet4.partner_id, self.project_customer.partner_id, 'Customer of new timesheet should be the same of the one set project (since no task on timesheet)')
def test_log_access_rights(self):
""" Test access rights : user can update its own timesheets only, and manager can change all """
@@ -145,7 +145,7 @@ class TestTimesheet(TestCommonTimesheet):
'unit_amount': 8,
'employee_id': self.empl_employee2.id,
})
- self.assertEquals(timesheet1.user_id, self.user_employee2, 'Changing timesheet employee should change the related user')
+ self.assertEqual(timesheet1.user_id, self.user_employee2, 'Changing timesheet employee should change the related user')
def test_create_unlink_project(self):
""" Check project creation, and if necessary the analytic account generated when project should track time. """
@@ -165,9 +165,9 @@ class TestTimesheet(TestCommonTimesheet):
})
self.assertTrue(tracked_project.analytic_account_id, "A time-tracked project should generate an analytic account")
self.assertTrue(tracked_project.analytic_account_id.active, "A time-tracked project should generate an active analytic account")
- self.assertEquals(tracked_project.partner_id, tracked_project.analytic_account_id.partner_id, "The generated AA should have the same partner as the project")
- self.assertEquals(tracked_project.name, tracked_project.analytic_account_id.name, "The generated AA should have the same name as the project")
- self.assertEquals(tracked_project.analytic_account_id.project_count, 1, "The generated AA should be linked to the project")
+ self.assertEqual(tracked_project.partner_id, tracked_project.analytic_account_id.partner_id, "The generated AA should have the same partner as the project")
+ self.assertEqual(tracked_project.name, tracked_project.analytic_account_id.name, "The generated AA should have the same name as the project")
+ self.assertEqual(tracked_project.analytic_account_id.project_count, 1, "The generated AA should be linked to the project")
# create a project without tracking time, but with analytic account
analytic_project = self.env['project.project'].create({
@@ -176,8 +176,8 @@ class TestTimesheet(TestCommonTimesheet):
'partner_id': self.partner.id,
'analytic_account_id': tracked_project.analytic_account_id.id,
})
- self.assertNotEquals(analytic_project.name, tracked_project.analytic_account_id.name, "The name of the associated AA can be different from the project")
- self.assertEquals(tracked_project.analytic_account_id.project_count, 2, "The AA should be linked to 2 project")
+ self.assertNotEqual(analytic_project.name, tracked_project.analytic_account_id.name, "The name of the associated AA can be different from the project")
+ self.assertEqual(tracked_project.analytic_account_id.project_count, 2, "The AA should be linked to 2 project")
# analytic linked to projects containing tasks can not be removed
task = self.env['project.task'].create({
@@ -211,9 +211,9 @@ class TestTimesheet(TestCommonTimesheet):
timesheet_count1 = Timesheet.search_count([('project_id', '=', self.project_customer.id)])
timesheet_count2 = Timesheet.search_count([('project_id', '=', self.project_customer2.id)])
- self.assertEquals(timesheet_count1, 1, "One timesheet in project 1")
- self.assertEquals(timesheet_count2, 0, "No timesheet in project 2")
- self.assertEquals(len(self.task1.timesheet_ids), 1, "The timesheet should be linked to task 1")
+ self.assertEqual(timesheet_count1, 1, "One timesheet in project 1")
+ self.assertEqual(timesheet_count2, 0, "No timesheet in project 2")
+ self.assertEqual(len(self.task1.timesheet_ids), 1, "The timesheet should be linked to task 1")
# change project of task 1
self.task1.write({
@@ -222,9 +222,9 @@ class TestTimesheet(TestCommonTimesheet):
timesheet_count1 = Timesheet.search_count([('project_id', '=', self.project_customer.id)])
timesheet_count2 = Timesheet.search_count([('project_id', '=', self.project_customer2.id)])
- self.assertEquals(timesheet_count1, 1, "Still one timesheet in project 1")
- self.assertEquals(timesheet_count2, 0, "No timesheet in project 2")
- self.assertEquals(len(self.task1.timesheet_ids), 1, "The timesheet still should be linked to task 1")
+ self.assertEqual(timesheet_count1, 1, "Still one timesheet in project 1")
+ self.assertEqual(timesheet_count2, 0, "No timesheet in project 2")
+ self.assertEqual(len(self.task1.timesheet_ids), 1, "The timesheet still should be linked to task 1")
# it is forbidden to set a task with timesheet without project
with self.assertRaises(UserError):
diff --git a/addons/l10n_be_edi/tests/test_ubl.py b/addons/l10n_be_edi/tests/test_ubl.py
index 0fa298584163..37ef7bd9984a 100644
--- a/addons/l10n_be_edi/tests/test_ubl.py
+++ b/addons/l10n_be_edi/tests/test_ubl.py
@@ -20,7 +20,7 @@ class TestUBL(common.TransactionCase):
attachment_id = self.env['ir.attachment'].create({
'name': 'efff_test.xml',
- 'datas': base64.encodestring(xml_file),
+ 'datas': base64.encodebytes(xml_file),
'res_id': invoice.id,
'res_model': 'account.move',
})
diff --git a/addons/l10n_fr_fec/wizard/account_fr_fec.py b/addons/l10n_fr_fec/wizard/account_fr_fec.py
index 8adab17adea9..476905a42e21 100644
--- a/addons/l10n_fr_fec/wizard/account_fr_fec.py
+++ b/addons/l10n_fr_fec/wizard/account_fr_fec.py
@@ -357,7 +357,7 @@ class AccountFrFec(models.TransientModel):
suffix = '-NONOFFICIAL'
self.write({
- 'fec_data': base64.encodestring(fecvalue),
+ 'fec_data': base64.encodebytes(fecvalue),
# Filename = <siren>FECYYYYMMDD where YYYMMDD is the closing date
'filename': '%sFEC%s%s.csv' % (company_legal_data['siren'], end_date, suffix),
})
diff --git a/addons/l10n_it_edi/models/account_invoice.py b/addons/l10n_it_edi/models/account_invoice.py
index 2938c6630ff1..5c0090165b3d 100644
--- a/addons/l10n_it_edi/models/account_invoice.py
+++ b/addons/l10n_it_edi/models/account_invoice.py
@@ -160,7 +160,7 @@ class AccountMove(models.Model):
'name': report_name,
'res_id': invoice.id,
'res_model': invoice._name,
- 'datas': base64.encodestring(data),
+ 'datas': base64.encodebytes(data),
'description': description,
'type': 'binary',
})
diff --git a/addons/l10n_it_edi/models/ir_mail_server.py b/addons/l10n_it_edi/models/ir_mail_server.py
index 51e4a0a23a3f..580635dfc3da 100644
--- a/addons/l10n_it_edi/models/ir_mail_server.py
+++ b/addons/l10n_it_edi/models/ir_mail_server.py
@@ -134,7 +134,7 @@ class FetchmailServer(models.Model):
invoice_attachment = self.env['ir.attachment'].create({
'name': att_name,
- 'datas': base64.encodestring(att_content),
+ 'datas': base64.encodebytes(att_content),
'type': 'binary',
})
diff --git a/addons/maintenance/tests/test_maintenance.py b/addons/maintenance/tests/test_maintenance.py
index 82909496691a..e4decedb5832 100644
--- a/addons/maintenance/tests/test_maintenance.py
+++ b/addons/maintenance/tests/test_maintenance.py
@@ -68,13 +68,13 @@ class TestEquipment(TransactionCase):
assert maintenance_request_01, "Maintenance Request not created"
# I check that Initially maintenance request is in the "New Request" stage
- self.assertEquals(maintenance_request_01.stage_id.id, self.ref('maintenance.stage_0'))
+ self.assertEqual(maintenance_request_01.stage_id.id, self.ref('maintenance.stage_0'))
# I check that change the maintenance_request stage on click statusbar
maintenance_request_01.with_user(self.user).write({'stage_id': self.ref('maintenance.stage_1')})
# I check that maintenance request is in the "In Progress" stage
- self.assertEquals(maintenance_request_01.stage_id.id, self.ref('maintenance.stage_1'))
+ self.assertEqual(maintenance_request_01.stage_id.id, self.ref('maintenance.stage_1'))
def test_20_cron(self):
""" Check the cron creates the necessary preventive maintenance requests"""
diff --git a/addons/maintenance/tests/test_maintenance_multicompany.py b/addons/maintenance/tests/test_maintenance_multicompany.py
index f535e7f4ce3f..7c615921f4b8 100644
--- a/addons/maintenance/tests/test_maintenance_multicompany.py
+++ b/addons/maintenance/tests/test_maintenance_multicompany.py
@@ -98,8 +98,8 @@ class TestEquipmentMulticompany(TransactionCase):
})
# Check category for user equipment_manager and user
- self.assertEquals(Category.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 3)
- self.assertEquals(Category.with_user(user).search_count([]), 2)
+ self.assertEqual(Category.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 3)
+ self.assertEqual(Category.with_user(user).search_count([]), 2)
# User should not able to create equipment.
with self.assertRaises(AccessError):
@@ -128,10 +128,10 @@ class TestEquipmentMulticompany(TransactionCase):
'owner_user_id': equipment_manager.id,
})
# Now there are total 2 equipments created and can view by equipment_manager user
- self.assertEquals(Equipment.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 2)
+ self.assertEqual(Equipment.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 2)
# And there is total 1 equipment can be view by Normal User ( Which user is followers)
- self.assertEquals(Equipment.with_user(user).search_count([]), 1)
+ self.assertEqual(Equipment.with_user(user).search_count([]), 1)
# create an equipment team BY user
with self.assertRaises(AccessError):
@@ -171,5 +171,5 @@ class TestEquipmentMulticompany(TransactionCase):
})
# Now here is total 1 maintenance request can be view by Normal User
- self.assertEquals(MaintenanceRequest.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 2)
- self.assertEquals(MaintenanceRequest.with_user(user).search_count([]), 1)
+ self.assertEqual(MaintenanceRequest.with_user(equipment_manager).with_context(allowed_company_ids=cids).search_count([]), 2)
+ self.assertEqual(MaintenanceRequest.with_user(user).search_count([]), 1)
diff --git a/addons/mrp/tests/test_procurement.py b/addons/mrp/tests/test_procurement.py
index 1b4f711b8560..7c40b0f73d2e 100644
--- a/addons/mrp/tests/test_procurement.py
+++ b/addons/mrp/tests/test_procurement.py
@@ -116,7 +116,7 @@ class TestProcurement(TestMrpCommon):
# set the product of `self.bom_1` to this child category
for bom_line_id in self.bom_1.bom_line_ids:
# check that no routes are defined on the product
- self.assertEquals(len(bom_line_id.product_id.route_ids), 0)
+ self.assertEqual(len(bom_line_id.product_id.route_ids), 0)
# set the category of the product to a child category
bom_line_id.product_id.categ_id = child_categ_id
diff --git a/addons/mrp/tests/test_stock.py b/addons/mrp/tests/test_stock.py
index 9a58cdc22cb9..c80e2bdf420a 100644
--- a/addons/mrp/tests/test_stock.py
+++ b/addons/mrp/tests/test_stock.py
@@ -348,9 +348,9 @@ class TestKitPicking(common.TestMrpCommon):
picking.button_validate()
# We check that the picking has the correct quantities after its move were splitted.
- self.assertEquals(len(picking.move_lines), 7)
+ self.assertEqual(len(picking.move_lines), 7)
for move_line in picking.move_lines:
- self.assertEquals(move_line.quantity_done, self.expected_quantities[move_line.product_id])
+ self.assertEqual(move_line.quantity_done, self.expected_quantities[move_line.product_id])
def test_kit_planned_transfer(self):
""" Make sure a kit is split in the corrects product_qty by components in case of a
@@ -376,6 +376,6 @@ class TestKitPicking(common.TestMrpCommon):
picking.action_confirm()
# We check that the picking has the correct quantities after its move were splitted.
- self.assertEquals(len(picking.move_lines), 7)
+ self.assertEqual(len(picking.move_lines), 7)
for move_line in picking.move_lines:
- self.assertEquals(move_line.product_qty, self.expected_quantities[move_line.product_id])
+ self.assertEqual(move_line.product_qty, self.expected_quantities[move_line.product_id])
diff --git a/addons/mrp/tests/test_warehouse_multistep_manufacturing.py b/addons/mrp/tests/test_warehouse_multistep_manufacturing.py
index 000701be638b..7402d2495b39 100644
--- a/addons/mrp/tests/test_warehouse_multistep_manufacturing.py
+++ b/addons/mrp/tests/test_warehouse_multistep_manufacturing.py
@@ -252,6 +252,6 @@ class TestMultistepManufacturingWarehouse(TestMrpCommon):
self.assertEqual(move_stock_postprod.state, 'waiting')
move_stock_preprod._action_cancel()
- self.assertEquals(production_order.state, 'confirmed')
+ self.assertEqual(production_order.state, 'confirmed')
production_order.action_cancel()
self.assertTrue(move_stock_postprod.state, 'cancel')
diff --git a/addons/mrp/tests/test_workorder_operation.py b/addons/mrp/tests/test_workorder_operation.py
index 68635a5bb218..e4efa917e7c5 100644
--- a/addons/mrp/tests/test_workorder_operation.py
+++ b/addons/mrp/tests/test_workorder_operation.py
@@ -539,8 +539,8 @@ class TestWorkOrderProcess(TestMrpCommon):
charger_done_move = mo_custom_laptop.move_raw_ids.filtered(lambda x: x.product_id.id == product_charger.id and x.state == 'done')
keybord_done_move = mo_custom_laptop.move_raw_ids.filtered(lambda x: x.product_id.id == product_keybord.id and x.state == 'done')
- self.assertEquals(charger_done_move.product_uom_qty, 12)
- self.assertEquals(keybord_done_move.product_uom_qty, 12)
+ self.assertEqual(charger_done_move.product_uom_qty, 12)
+ self.assertEqual(keybord_done_move.product_uom_qty, 12)
# Produce remaining 4 quantity
# ----------------------------
@@ -552,13 +552,13 @@ class TestWorkOrderProcess(TestMrpCommon):
laptop_lot_002 = self.env['stock.production.lot'].create({'product_id': custom_laptop.id, 'company_id': self.env.company.id})
produce_form.finished_lot_id = laptop_lot_002
product_consume = produce_form.save()
- self.assertEquals(len(product_consume._workorder_line_ids()), 2)
+ self.assertEqual(len(product_consume._workorder_line_ids()), 2)
product_consume._workorder_line_ids()[0].qty_done = 8
product_consume.do_produce()
charger_move = mo_custom_laptop.move_raw_ids.filtered(lambda x: x.product_id.id == product_charger.id and x.state != 'done')
keybord_move = mo_custom_laptop.move_raw_ids.filtered(lambda x: x.product_id.id == product_keybord.id and x.state !='done')
- self.assertEquals(charger_move.quantity_done, 8, "Wrong consumed quantity of %s" % charger_move.product_id.name)
- self.assertEquals(keybord_move.quantity_done, 8, "Wrong consumed quantity of %s" % keybord_move.product_id.name)
+ self.assertEqual(charger_move.quantity_done, 8, "Wrong consumed quantity of %s" % charger_move.product_id.name)
+ self.assertEqual(keybord_move.quantity_done, 8, "Wrong consumed quantity of %s" % keybord_move.product_id.name)
# Post Inventory of production order.
mo_custom_laptop.post_inventory()
@@ -690,7 +690,7 @@ class TestWorkOrderProcess(TestMrpCommon):
produce_form.finished_lot_id = lot_a
product_consume = produce_form.save()
# laptop_lot_002 = self.env['stock.production.lot'].create({'product_id': custom_laptop.id})
- self.assertEquals(len(product_consume._workorder_line_ids()), 2)
+ self.assertEqual(len(product_consume._workorder_line_ids()), 2)
product_consume._workorder_line_ids().filtered(lambda x: x.product_id == product_C).write({'qty_done': 3000})
product_consume._workorder_line_ids().filtered(lambda x: x.product_id == product_B).write({'qty_done': 20})
product_consume.do_produce()
diff --git a/addons/mrp_account/tests/test_bom_price.py b/addons/mrp_account/tests/test_bom_price.py
index c91f6203bca5..1273e3ecdba2 100644
--- a/addons/mrp_account/tests/test_bom_price.py
+++ b/addons/mrp_account/tests/test_bom_price.py
@@ -178,10 +178,10 @@ class TestBom(common.TransactionCase):
self.assertEqual(self.dining_table.standard_price, 1000, "Initial price of the Product should be 1000")
self.dining_table.button_bom_cost()
# Total cost of Dining Table = (550) + Total cost of operations (125) = 675.0
- self.assertEquals(float_round(self.dining_table.standard_price, precision_digits=2), 675.0, "After computing price from BoM price should be 612.5")
+ self.assertEqual(float_round(self.dining_table.standard_price, precision_digits=2), 675.0, "After computing price from BoM price should be 612.5")
self.Product.browse([self.dining_table.id, self.table_head.id]).action_bom_cost()
# Total cost of Dining Table = (718.75) + Total cost of all operations (125 + 10.42) = 854.17
- self.assertEquals(float_compare(self.dining_table.standard_price, 854.17, precision_digits=2), 0, "After computing price from BoM price should be 786.46")
+ self.assertEqual(float_compare(self.dining_table.standard_price, 854.17, precision_digits=2), 0, "After computing price from BoM price should be 786.46")
def test_01_compute_price_inventory_valuation(self):
"""Test update cost from bom in list view when inventory valuation is real time."""
diff --git a/addons/mrp_subcontracting/tests/test_subcontracting.py b/addons/mrp_subcontracting/tests/test_subcontracting.py
index 029d9e3a71f3..148f99e1816b 100644
--- a/addons/mrp_subcontracting/tests/test_subcontracting.py
+++ b/addons/mrp_subcontracting/tests/test_subcontracting.py
@@ -46,7 +46,7 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
self.assertEqual(len(mo), 1)
self.assertEqual(len(mo.picking_ids), 0)
wh = picking_receipt.picking_type_id.warehouse_id
- self.assertEquals(mo.picking_type_id, wh.subcontracting_type_id)
+ self.assertEqual(mo.picking_type_id, wh.subcontracting_type_id)
self.assertFalse(mo.picking_type_id.active)
# Create a RR
@@ -64,18 +64,18 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
self.env['procurement.group'].run_scheduler()
picking = self.env['stock.picking'].search([('group_id', '=', pg1.id)])
self.assertEqual(len(picking), 1)
- self.assertEquals(picking.picking_type_id, wh.out_type_id)
+ self.assertEqual(picking.picking_type_id, wh.out_type_id)
picking_receipt.move_lines.quantity_done = 1
picking_receipt.button_validate()
- self.assertEquals(mo.state, 'done')
+ self.assertEqual(mo.state, 'done')
# Available quantities should be negative at the subcontracting location for each components
avail_qty_comp1 = self.env['stock.quant']._get_available_quantity(self.comp1, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_comp2 = self.env['stock.quant']._get_available_quantity(self.comp2, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_finished = self.env['stock.quant']._get_available_quantity(self.finished, wh.lot_stock_id)
- self.assertEquals(avail_qty_comp1, -1)
- self.assertEquals(avail_qty_comp2, -1)
- self.assertEquals(avail_qty_finished, 1)
+ self.assertEqual(avail_qty_comp1, -1)
+ self.assertEqual(avail_qty_comp2, -1)
+ self.assertEqual(avail_qty_finished, 1)
# Ensure returns to subcontractor location
return_form = Form(self.env['stock.return.picking'].with_context(active_id=picking_receipt.id, active_model='stock.picking'))
@@ -126,16 +126,16 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
# Pickings should directly be created
mo = self.env['mrp.production'].search([('bom_id', '=', self.bom.id)])
self.assertEqual(len(mo.picking_ids), 1)
- self.assertEquals(mo.state, 'confirmed')
+ self.assertEqual(mo.state, 'confirmed')
self.assertEqual(len(mo.picking_ids.move_lines), 2)
picking = mo.picking_ids
wh = picking.picking_type_id.warehouse_id
# The picking should be a delivery order
- self.assertEquals(picking.picking_type_id, wh.out_type_id)
+ self.assertEqual(picking.picking_type_id, wh.out_type_id)
- self.assertEquals(mo.picking_type_id, wh.subcontracting_type_id)
+ self.assertEqual(mo.picking_type_id, wh.subcontracting_type_id)
self.assertFalse(mo.picking_type_id.active)
# No manufacturing order for `self.comp2`
@@ -144,15 +144,15 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
picking_receipt.move_lines.quantity_done = 1
picking_receipt.button_validate()
- self.assertEquals(mo.state, 'done')
+ self.assertEqual(mo.state, 'done')
# Available quantities should be negative at the subcontracting location for each components
avail_qty_comp1 = self.env['stock.quant']._get_available_quantity(self.comp1, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_comp2 = self.env['stock.quant']._get_available_quantity(self.comp2, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_finished = self.env['stock.quant']._get_available_quantity(self.finished, wh.lot_stock_id)
- self.assertEquals(avail_qty_comp1, -1)
- self.assertEquals(avail_qty_comp2, -1)
- self.assertEquals(avail_qty_finished, 1)
+ self.assertEqual(avail_qty_comp1, -1)
+ self.assertEqual(avail_qty_comp2, -1)
+ self.assertEqual(avail_qty_finished, 1)
avail_qty_comp1_in_global_location = self.env['stock.quant']._get_available_quantity(self.comp1, self.env.company.subcontracting_location_id, allow_negative=True)
avail_qty_comp2_in_global_location = self.env['stock.quant']._get_available_quantity(self.comp2, self.env.company.subcontracting_location_id, allow_negative=True)
@@ -190,19 +190,19 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
# Pickings should directly be created
mo = self.env['mrp.production'].search([('bom_id', '=', self.bom.id)])
- self.assertEquals(mo.state, 'confirmed')
+ self.assertEqual(mo.state, 'confirmed')
picking_delivery = mo.picking_ids
self.assertEqual(len(picking_delivery), 1)
self.assertEqual(len(picking_delivery.move_lines), 2)
- self.assertEquals(picking_delivery.origin, picking_receipt.name)
- self.assertEquals(picking_delivery.partner_id, picking_receipt.partner_id)
+ self.assertEqual(picking_delivery.origin, picking_receipt.name)
+ self.assertEqual(picking_delivery.partner_id, picking_receipt.partner_id)
# The picking should be a delivery order
wh = picking_receipt.picking_type_id.warehouse_id
- self.assertEquals(mo.picking_ids.picking_type_id, wh.out_type_id)
+ self.assertEqual(mo.picking_ids.picking_type_id, wh.out_type_id)
- self.assertEquals(mo.picking_type_id, wh.subcontracting_type_id)
+ self.assertEqual(mo.picking_type_id, wh.subcontracting_type_id)
self.assertFalse(mo.picking_type_id.active)
# As well as a manufacturing order for `self.comp2`
@@ -210,15 +210,15 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
self.assertEqual(len(comp2mo), 1)
picking_receipt.move_lines.quantity_done = 1
picking_receipt.button_validate()
- self.assertEquals(mo.state, 'done')
+ self.assertEqual(mo.state, 'done')
# Available quantities should be negative at the subcontracting location for each components
avail_qty_comp1 = self.env['stock.quant']._get_available_quantity(self.comp1, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_comp2 = self.env['stock.quant']._get_available_quantity(self.comp2, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_finished = self.env['stock.quant']._get_available_quantity(self.finished, wh.lot_stock_id)
- self.assertEquals(avail_qty_comp1, -1)
- self.assertEquals(avail_qty_comp2, -1)
- self.assertEquals(avail_qty_finished, 1)
+ self.assertEqual(avail_qty_comp1, -1)
+ self.assertEqual(avail_qty_comp2, -1)
+ self.assertEqual(avail_qty_finished, 1)
def test_flow_4(self):
""" Tick "Manufacture" and "MTO" on the components and trigger the
@@ -254,7 +254,7 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
# Pickings should directly be created
mo = self.env['mrp.production'].search([('bom_id', '=', self.bom.id)])
- self.assertEquals(mo.state, 'confirmed')
+ self.assertEqual(mo.state, 'confirmed')
picking_delivery = mo.picking_ids
self.assertFalse(picking_delivery)
@@ -340,10 +340,10 @@ class TestSubcontractingFlows(TestMrpSubcontractingCommon):
mo_pick1 = picking_receipt1.move_lines.mapped('move_orig_ids.production_id')
mo_pick2 = picking_receipt2.move_lines.mapped('move_orig_ids.production_id')
- self.assertEquals(len(mo_pick1), 1)
- self.assertEquals(len(mo_pick2), 1)
- self.assertEquals(mo_pick1.bom_id, self.bom)
- self.assertEquals(mo_pick2.bom_id, bom2)
+ self.assertEqual(len(mo_pick1), 1)
+ self.assertEqual(len(mo_pick2), 1)
+ self.assertEqual(mo_pick1.bom_id, self.bom)
+ self.assertEqual(mo_pick2.bom_id, bom2)
def test_flow_6(self):
""" Extra quantity on the move.
@@ -573,10 +573,10 @@ class TestSubcontractingTracking(TransactionCase):
# Check the created manufacturing order
mo = self.env['mrp.production'].search([('bom_id', '=', self.bom_tracked.id)])
self.assertEqual(len(mo), 1)
- self.assertEquals(mo.state, 'confirmed')
+ self.assertEqual(mo.state, 'confirmed')
self.assertEqual(len(mo.picking_ids), 0)
wh = picking_receipt.picking_type_id.warehouse_id
- self.assertEquals(mo.picking_type_id, wh.subcontracting_type_id)
+ self.assertEqual(mo.picking_type_id, wh.subcontracting_type_id)
self.assertFalse(mo.picking_type_id.active)
# Create a RR
@@ -594,7 +594,7 @@ class TestSubcontractingTracking(TransactionCase):
self.env['procurement.group'].run_scheduler()
picking = self.env['stock.picking'].search([('group_id', '=', pg1.id)])
self.assertEqual(len(picking), 1)
- self.assertEquals(picking.picking_type_id, wh.out_type_id)
+ self.assertEqual(picking.picking_type_id, wh.out_type_id)
lot_id = self.env['stock.production.lot'].create({
'name': 'lot1',
@@ -621,12 +621,12 @@ class TestSubcontractingTracking(TransactionCase):
picking_receipt.move_lines.quantity_done = 1
picking_receipt.move_lines.move_line_ids.lot_id = lot_id.id
picking_receipt.button_validate()
- self.assertEquals(mo.state, 'done')
+ self.assertEqual(mo.state, 'done')
# Available quantities should be negative at the subcontracting location for each components
avail_qty_comp1 = self.env['stock.quant']._get_available_quantity(self.comp1_sn, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_comp2 = self.env['stock.quant']._get_available_quantity(self.comp2, self.subcontractor_partner1.property_stock_subcontractor, allow_negative=True)
avail_qty_finished = self.env['stock.quant']._get_available_quantity(self.finished_lot, wh.lot_stock_id)
- self.assertEquals(avail_qty_comp1, -1)
- self.assertEquals(avail_qty_comp2, -1)
- self.assertEquals(avail_qty_finished, 1)
+ self.assertEqual(avail_qty_comp1, -1)
+ self.assertEqual(avail_qty_comp2, -1)
+ self.assertEqual(avail_qty_finished, 1)
diff --git a/addons/payment_stripe/models/payment.py b/addons/payment_stripe/models/payment.py
index 9272f194cbf8..4e68d122bc1b 100644
--- a/addons/payment_stripe/models/payment.py
+++ b/addons/payment_stripe/models/payment.py
@@ -246,7 +246,7 @@ class PaymentTransactionStripe(models.Model):
return True
else:
error = tree.get('failure_message')
- _logger.warn(error)
+ _logger.warning(error)
vals.update({'state_message': error})
self.write(vals)
self._set_transaction_cancel()
diff --git a/addons/pos_cache/models/pos_cache.py b/addons/pos_cache/models/pos_cache.py
index 8987907f9811..74e2a99019b6 100644
--- a/addons/pos_cache/models/pos_cache.py
+++ b/addons/pos_cache/models/pos_cache.py
@@ -30,7 +30,7 @@ class pos_cache(models.Model):
display_default_code=False, lang=cache.compute_user_id.lang)
res = prod_ctx.read(cache.get_product_fields())
cache.write({
- 'cache': base64.encodestring(json.dumps(res).encode('utf-8')),
+ 'cache': base64.encodebytes(json.dumps(res).encode('utf-8')),
})
@api.model
@@ -48,7 +48,7 @@ class pos_cache(models.Model):
self.product_fields = str(fields)
self.refresh_cache()
- return json.loads(base64.decodestring(self.cache).decode('utf-8'))
+ return json.loads(base64.decodebytes(self.cache).decode('utf-8'))
class pos_config(models.Model):
diff --git a/addons/project_timesheet_holidays/tests/test_timesheet_holidays.py b/addons/project_timesheet_holidays/tests/test_timesheet_holidays.py
index 6aad4f1e51a0..84c80cb133a9 100644
--- a/addons/project_timesheet_holidays/tests/test_timesheet_holidays.py
+++ b/addons/project_timesheet_holidays/tests/test_timesheet_holidays.py
@@ -98,11 +98,11 @@ class TestTimesheetHolidays(TestCommonTimesheet):
'number_of_days': number_of_days,
})
holiday.with_user(SUPERUSER_ID).action_validate()
- self.assertEquals(len(holiday.timesheet_ids), number_of_days, 'Number of generated timesheets should be the same as the leave duration (1 per day between %s and %s)' % (fields.Datetime.to_string(self.leave_start_datetime), fields.Datetime.to_string(self.leave_end_datetime)))
+ self.assertEqual(len(holiday.timesheet_ids), number_of_days, 'Number of generated timesheets should be the same as the leave duration (1 per day between %s and %s)' % (fields.Datetime.to_string(self.leave_start_datetime), fields.Datetime.to_string(self.leave_end_datetime)))
# manager refuse the leave
holiday.with_user(SUPERUSER_ID).action_refuse()
- self.assertEquals(len(holiday.timesheet_ids), 0, 'Number of linked timesheets should be zero, since the leave is refused.')
+ self.assertEqual(len(holiday.timesheet_ids), 0, 'Number of linked timesheets should be zero, since the leave is refused.')
def test_validate_without_timesheet(self):
# employee creates a leave request
@@ -116,4 +116,4 @@ class TestTimesheetHolidays(TestCommonTimesheet):
'number_of_days': number_of_days,
})
holiday.with_user(SUPERUSER_ID).action_validate()
- self.assertEquals(len(holiday.timesheet_ids), 0, 'Number of generated timesheets should be zero since the leave type does not generate timesheet')
+ self.assertEqual(len(holiday.timesheet_ids), 0, 'Number of generated timesheets should be zero since the leave type does not generate timesheet')
diff --git a/addons/purchase/tests/test_purchase_order_report.py b/addons/purchase/tests/test_purchase_order_report.py
index 9497348e3ab4..163df4bc3ec3 100644
--- a/addons/purchase/tests/test_purchase_order_report.py
+++ b/addons/purchase/tests/test_purchase_order_report.py
@@ -67,14 +67,14 @@ class TestPurchaseOrderReport(common.TransactionCase):
('order_id', '=', po.id), ('product_id', '=', self.product1.id)])
# check that report will convert dozen to unit or not
- self.assertEquals(res_product1.qty_ordered, 12.0, 'UoM conversion is not working')
+ self.assertEqual(res_product1.qty_ordered, 12.0, 'UoM conversion is not working')
# report should show in company currency (amount/rate) = (100/2)
- self.assertEquals(res_product1.price_total, 50.0, 'Currency conversion is not working')
+ self.assertEqual(res_product1.price_total, 50.0, 'Currency conversion is not working')
res_product2 = self.PurchaseReport.search([
('order_id', '=', po.id), ('product_id', '=', self.product2.id)])
# Check that repost should show 6 unit of product
- self.assertEquals(res_product2.qty_ordered, 12.0, 'UoM conversion is not working')
+ self.assertEqual(res_product2.qty_ordered, 12.0, 'UoM conversion is not working')
# report should show in company currency (amount/rate) = (200/2)
- self.assertEquals(res_product2.price_total, 100.0, 'Currency conversion is not working')
+ self.assertEqual(res_product2.price_total, 100.0, 'Currency conversion is not working')
diff --git a/addons/purchase_mrp/tests/test_purchase_mrp_flow.py b/addons/purchase_mrp/tests/test_purchase_mrp_flow.py
index ea99478a93b7..03f17161fe80 100644
--- a/addons/purchase_mrp/tests/test_purchase_mrp_flow.py
+++ b/addons/purchase_mrp/tests/test_purchase_mrp_flow.py
@@ -177,7 +177,7 @@ class TestSaleMrpFlow(TransactionCase):
"""
moves_to_process = moves.filtered(lambda m: m.product_id in quantities_to_process.keys())
for move in moves_to_process:
- self.assertEquals(move.product_uom_qty, quantities_to_process[move.product_id])
+ self.assertEqual(move.product_uom_qty, quantities_to_process[move.product_id])
def _create_move_quantities(self, qty_to_process, components, warehouse):
""" Helper to creates moves in order to update the quantities of components
@@ -237,7 +237,7 @@ class TestSaleMrpFlow(TransactionCase):
# Check picking creation, its move lines should concern
# only components. Also checks that the quantities are corresponding
# to the PO
- self.assertEquals(len(po.picking_ids), 1)
+ self.assertEqual(len(po.picking_ids), 1)
order_line = po.order_line[0]
picking_original = po.picking_ids[0]
move_lines = picking_original.move_lines
@@ -255,7 +255,7 @@ class TestSaleMrpFlow(TransactionCase):
self.component_g: 28.0
}
- self.assertEquals(len(move_lines), 7)
+ self.assertEqual(len(move_lines), 7)
self.assertTrue(not any(kit in products for kit in kits))
self.assertTrue(all(component in products for component in components))
self._assert_quantities(move_lines, expected_quantities)
@@ -269,13 +269,13 @@ class TestSaleMrpFlow(TransactionCase):
backorder_wizard.process()
# Check that a backorded is created
- self.assertEquals(len(po.picking_ids), 2)
+ self.assertEqual(len(po.picking_ids), 2)
backorder_1 = po.picking_ids - picking_original
- self.assertEquals(backorder_1.backorder_id.id, picking_original.id)
+ self.assertEqual(backorder_1.backorder_id.id, picking_original.id)
# Even if some components are received completely,
# no KitParent should be received
- self.assertEquals(order_line.qty_received, 0)
+ self.assertEqual(order_line.qty_received, 0)
# Process just enough components to make 1 kit_parent
qty_to_process = {
@@ -289,12 +289,12 @@ class TestSaleMrpFlow(TransactionCase):
backorder_wizard.process()
# Only 1 kit_parent should be received at this point
- self.assertEquals(order_line.qty_received, 1)
+ self.assertEqual(order_line.qty_received, 1)
# Check that the second backorder is created
- self.assertEquals(len(po.picking_ids), 3)
+ self.assertEqual(len(po.picking_ids), 3)
backorder_2 = po.picking_ids - picking_original - backorder_1
- self.assertEquals(backorder_2.backorder_id.id, backorder_1.id)
+ self.assertEqual(backorder_2.backorder_id.id, backorder_1.id)
# Set the components quantities that backorder_2 should have
expected_quantities = {
@@ -309,7 +309,7 @@ class TestSaleMrpFlow(TransactionCase):
# Check that the computed quantities are matching the theorical ones.
# Since component_e was totally processed, this componenent shouldn't be
# present in backorder_2
- self.assertEquals(len(backorder_2.move_lines), 6)
+ self.assertEqual(len(backorder_2.move_lines), 6)
move_comp_e = backorder_2.move_lines.filtered(lambda m: m.product_id.id == self.component_e.id)
self.assertFalse(move_comp_e)
self._assert_quantities(backorder_2.move_lines, expected_quantities)
@@ -328,12 +328,12 @@ class TestSaleMrpFlow(TransactionCase):
backorder_wizard.process()
# Check that x3 kit_parents are indeed received
- self.assertEquals(order_line.qty_received, 3)
+ self.assertEqual(order_line.qty_received, 3)
# Check that the third backorder is created
- self.assertEquals(len(po.picking_ids), 4)
+ self.assertEqual(len(po.picking_ids), 4)
backorder_3 = po.picking_ids - (picking_original + backorder_1 + backorder_2)
- self.assertEquals(backorder_3.backorder_id.id, backorder_2.id)
+ self.assertEqual(backorder_3.backorder_id.id, backorder_2.id)
# Check the components quantities that backorder_3 should have
expected_quantities = {
@@ -352,7 +352,7 @@ class TestSaleMrpFlow(TransactionCase):
# Validating the last backorder now it's complete.
# All kits should be received
backorder_3.button_validate()
- self.assertEquals(order_line.qty_received, 7.0)
+ self.assertEqual(order_line.qty_received, 7.0)
# Return all components processed by backorder_3
stock_return_picking_form = Form(self.env['stock.return.picking']
@@ -373,7 +373,7 @@ class TestSaleMrpFlow(TransactionCase):
wiz.process()
# Now quantity received should be 3 again
- self.assertEquals(order_line.qty_received, 3)
+ self.assertEqual(order_line.qty_received, 3)
stock_return_picking_form = Form(self.env['stock.return.picking']
.with_context(active_ids=return_pick.ids, active_id=return_pick.ids[0],
@@ -395,14 +395,14 @@ class TestSaleMrpFlow(TransactionCase):
backorder_wizard.process()
# As one of each component is missing, only 6 kit_parents should be received
- self.assertEquals(order_line.qty_received, 6)
+ self.assertEqual(order_line.qty_received, 6)
# Check that the 4th backorder is created.
- self.assertEquals(len(po.picking_ids), 7)
+ self.assertEqual(len(po.picking_ids), 7)
backorder_4 = po.picking_ids - (
picking_original + backorder_1 + backorder_2 + backorder_3 + return_of_return_pick + return_pick)
- self.assertEquals(backorder_4.backorder_id.id, return_of_return_pick.id)
+ self.assertEqual(backorder_4.backorder_id.id, return_of_return_pick.id)
# Check the components quantities that backorder_4 should have
for move in backorder_4.move_lines:
- self.assertEquals(move.product_qty, 1)
+ self.assertEqual(move.product_qty, 1)
diff --git a/addons/purchase_stock/tests/test_create_picking.py b/addons/purchase_stock/tests/test_create_picking.py
index de209d063199..c042167d1643 100644
--- a/addons/purchase_stock/tests/test_create_picking.py
+++ b/addons/purchase_stock/tests/test_create_picking.py
@@ -446,7 +446,7 @@ class TestCreatePicking(common.TestProductCommon):
purchase_order_line.write({'date_planned': purchase_order_line.date_planned + timedelta(days=5)})
# Now check scheduled date of delivery order is changed or not.
- self.assertEquals(purchase_order_line.date_planned, delivery_order.scheduled_date,
+ self.assertEqual(purchase_order_line.date_planned, delivery_order.scheduled_date,
'Delivery order schedule date should be changed as we have set date propagate.')
def test_06_no_propagate_date(self):
@@ -466,5 +466,5 @@ class TestCreatePicking(common.TestProductCommon):
purchase_order_line.write({'date_planned': purchase_order_line.date_planned + timedelta(days=5)})
# Now check scheduled date of delivery order is changed or not.
- self.assertNotEquals(purchase_order_line.date_planned, delivery_order.scheduled_date,
+ self.assertNotEqual(purchase_order_line.date_planned, delivery_order.scheduled_date,
'Delivery order schedule date should not changed.')
diff --git a/addons/purchase_stock/tests/test_fifo_price.py b/addons/purchase_stock/tests/test_fifo_price.py
index 7ea86d557207..39f83213cb74 100644
--- a/addons/purchase_stock/tests/test_fifo_price.py
+++ b/addons/purchase_stock/tests/test_fifo_price.py
@@ -47,7 +47,7 @@ class TestFifoPrice(TestPurchase):
purchase_order_1.button_confirm()
# Check the "Purchase" status of purchase order 1
- self.assertEquals(purchase_order_1.state, 'purchase')
+ self.assertEqual(purchase_order_1.state, 'purchase')
# Process the reception of purchase order 1 and set date
picking = purchase_order_1.picking_ids[0]
@@ -55,8 +55,8 @@ class TestFifoPrice(TestPurchase):
# Check the standard price of the product (fifo icecream), that should have not changed
# because the standard price is supposed to be updated only when goods are going out of the stock
- self.assertEquals(product_cable_management_box.standard_price, 70.0, 'Standard price should not have changed')
- self.assertEquals(product_cable_management_box.value_svl, 500.0, 'Wrong stock value')
+ self.assertEqual(product_cable_management_box.standard_price, 70.0, 'Standard price should not have changed')
+ self.assertEqual(product_cable_management_box.value_svl, 500.0, 'Wrong stock value')
# I create a draft Purchase Order for second shipment for 30 kg at 80 euro
purchase_order_2 = self.env['purchase.order'].create({
@@ -79,8 +79,8 @@ class TestFifoPrice(TestPurchase):
# Check the standard price of the product, that should have not changed because the
# standard price is supposed to be updated only when goods are going out of the stock
- self.assertEquals(product_cable_management_box.standard_price, 70.0, 'Standard price as fifo price of second reception incorrect!')
- self.assertEquals(product_cable_management_box.value_svl, 2900.0, 'Stock valuation should be 2900')
+ self.assertEqual(product_cable_management_box.standard_price, 70.0, 'Standard price as fifo price of second reception incorrect!')
+ self.assertEqual(product_cable_management_box.value_svl, 2900.0, 'Stock valuation should be 2900')
# Let us send some goods
outgoing_shipment = self.env['stock.picking'].create({
@@ -313,5 +313,5 @@ class TestFifoPrice(TestPurchase):
self.env['stock.immediate.transfer'].create({'pick_ids': [(4, picking.id)]}).process()
original_out_move = outgoing_shipment_neg.move_lines[0]
- self.assertEquals(original_out_move.product_id.value_svl, 12000.0, 'Value of the move should be 12000')
- self.assertEquals(original_out_move.product_id.qty_available, 150.0, 'Qty available should be 150')
+ self.assertEqual(original_out_move.product_id.value_svl, 12000.0, 'Value of the move should be 12000')
+ self.assertEqual(original_out_move.product_id.qty_available, 150.0, 'Qty available should be 150')
diff --git a/addons/purchase_stock/tests/test_move_cancel_propagation.py b/addons/purchase_stock/tests/test_move_cancel_propagation.py
index 2c7aeda07195..9203927c4709 100644
--- a/addons/purchase_stock/tests/test_move_cancel_propagation.py
+++ b/addons/purchase_stock/tests/test_move_cancel_propagation.py
@@ -95,7 +95,7 @@ class TestMoveCancelPropagation(TestPurchase):
purchase_order .button_cancel()
# Check the status of picking after canceling po.
- self.assertEquals(picking_in.state, 'cancel')
+ self.assertEqual(picking_in.state, 'cancel')
self.assertNotEqual(self.picking_out.state, 'cancel')
def test_03_cancel_draft_purchase_order_two_steps(self):
diff --git a/addons/purchase_stock/tests/test_onchange_product.py b/addons/purchase_stock/tests/test_onchange_product.py
index 74361778fd52..3628d75affe7 100644
--- a/addons/purchase_stock/tests/test_onchange_product.py
+++ b/addons/purchase_stock/tests/test_onchange_product.py
@@ -72,16 +72,16 @@ class TestOnchangeProductId(TransactionCase):
po_line = po.order_line[0]
po_line.onchange_product_id()
- self.assertEquals(100, po_line.price_unit, "The included tax must be subtracted to the price")
+ self.assertEqual(100, po_line.price_unit, "The included tax must be subtracted to the price")
supplierinfo.write({'min_qty': 24})
po_line.write({'product_qty': 20})
po_line._onchange_quantity()
- self.assertEquals(0, po_line.price_unit, "Unit price should be reset to 0 since the supplier supplies minimum of 24 quantities")
+ self.assertEqual(0, po_line.price_unit, "Unit price should be reset to 0 since the supplier supplies minimum of 24 quantities")
po_line.write({'product_qty': 3, 'product_uom': self.ref("uom.product_uom_dozen")})
po_line._onchange_quantity()
- self.assertEquals(1200, po_line.price_unit, "Unit price should be 1200 for one Dozen")
+ self.assertEqual(1200, po_line.price_unit, "Unit price should be 1200 for one Dozen")
product_ipad = self.env.ref('product.product_product_4')
po_line2 = self.po_line_model.create({
@@ -94,4 +94,4 @@ class TestOnchangeProductId(TransactionCase):
'date_planned': fields.Date().today()
})
po_line2.onchange_product_id()
- self.assertEquals(0, po_line2.price_unit, "No vendor supplies this product, hence unit price should be set to 0")
+ self.assertEqual(0, po_line2.price_unit, "No vendor supplies this product, hence unit price should be set to 0")
diff --git a/addons/purchase_stock/tests/test_stockvaluation.py b/addons/purchase_stock/tests/test_stockvaluation.py
index 9490d218f171..24937f6d1d9b 100644
--- a/addons/purchase_stock/tests/test_stockvaluation.py
+++ b/addons/purchase_stock/tests/test_stockvaluation.py
@@ -74,13 +74,13 @@ class TestStockValuation(TransactionCase):
move1 = picking1.move_lines[0]
# the unit price of the purchase order line is copied to the in move
- self.assertEquals(move1.price_unit, 100)
+ self.assertEqual(move1.price_unit, 100)
# update the unit price on the purchase order line
po1.order_line.price_unit = 200
# the unit price on the stock move is not directly updated
- self.assertEquals(move1.price_unit, 100)
+ self.assertEqual(move1.price_unit, 100)
# validate the receipt
res_dict = picking1.button_validate()
@@ -88,9 +88,9 @@ class TestStockValuation(TransactionCase):
wizard.process()
# the unit price of the valuationlayer used the latest value
- self.assertEquals(move1.stock_valuation_layer_ids.unit_cost, 200)
+ self.assertEqual(move1.stock_valuation_layer_ids.unit_cost, 200)
- self.assertEquals(self.product1.value_svl, 2000)
+ self.assertEqual(self.product1.value_svl, 2000)
def test_standard_price_change_1(self):
""" Confirm a purchase order and create the associated receipt, change the unit cost of the
@@ -122,13 +122,13 @@ class TestStockValuation(TransactionCase):
# the move's unit price reflects the purchase order line's cost even if it's useless when
# the product's cost method is standard
- self.assertEquals(move1.price_unit, 11)
+ self.assertEqual(move1.price_unit, 11)
# set a new standard price
self.product1.product_tmpl_id.standard_price = 12
# the unit price on the stock move is not directly updated
- self.assertEquals(move1.price_unit, 11)
+ self.assertEqual(move1.price_unit, 11)
# validate the receipt
res_dict = picking1.button_validate()
@@ -136,9 +136,9 @@ class TestStockValuation(TransactionCase):
wizard.process()
# the unit price of the valuation layer used the latest value
- self.assertEquals(move1.stock_valuation_layer_ids.unit_cost, 12)
+ self.assertEqual(move1.stock_valuation_layer_ids.unit_cost, 12)
- self.assertEquals(self.product1.value_svl, 120)
+ self.assertEqual(self.product1.value_svl, 120)
def test_change_currency_rate_average_1(self):
""" Confirm a purchase order in another currency and create the associated receipt, change
@@ -460,17 +460,17 @@ class TestStockValuationWithCOA(AccountingTestCase):
# Check what was posted in the price difference account
price_diff_aml = self.env['account.move.line'].search([('account_id','=', self.price_diff_account.id)])
- self.assertEquals(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
- self.assertAlmostEquals(price_diff_aml.debit, 5, "Price difference should be equal to 5 (15-10)")
+ self.assertEqual(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
+ self.assertAlmostEqual(price_diff_aml.debit, 5, "Price difference should be equal to 5 (15-10)")
# Check what was posted in stock input account
input_aml = self.env['account.move.line'].search([('account_id','=',self.stock_input_account.id)])
- self.assertEquals(len(input_aml), 3, "Only three lines should have been generated in stock input account: one when receiving the product, one when making the invoice.")
+ self.assertEqual(len(input_aml), 3, "Only three lines should have been generated in stock input account: one when receiving the product, one when making the invoice.")
invoice_amls = input_aml.filtered(lambda l: l.move_id == invoice)
picking_aml = input_aml - invoice_amls
- self.assertAlmostEquals(sum(invoice_amls.mapped('debit')), 15, "Total debit value on stock input account should be equal to the original PO price of the product.")
- self.assertAlmostEquals(sum(invoice_amls.mapped('credit')), 5, "Total debit value on stock input account should be equal to the original PO price of the product.")
- self.assertAlmostEquals(sum(picking_aml.mapped('credit')), 10, "Total credit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(invoice_amls.mapped('debit')), 15, "Total debit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(invoice_amls.mapped('credit')), 5, "Total debit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(picking_aml.mapped('credit')), 10, "Total credit value on stock input account should be equal to the original PO price of the product.")
def test_valuation_from_increasing_tax(self):
""" Check that a tax without account will increment the stock value.
@@ -1207,14 +1207,14 @@ class TestStockValuationWithCOA(AccountingTestCase):
# Check what was posted in the price difference account
price_diff_aml = self.env['account.move.line'].search([('account_id','=', self.price_diff_account.id)])
- self.assertEquals(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
- self.assertAlmostEquals(price_diff_aml.credit, 20, "Price difference should be equal to 20 (110-90)")
+ self.assertEqual(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
+ self.assertAlmostEqual(price_diff_aml.credit, 20, "Price difference should be equal to 20 (110-90)")
# Check what was posted in stock input account
input_aml = self.env['account.move.line'].search([('account_id','=', self.stock_input_account.id)])
- self.assertEquals(len(input_aml), 3, "Only two lines should have been generated in stock input account: one when receiving the product, two when making the invoice.")
- self.assertAlmostEquals(sum(input_aml.mapped('debit')), 110, "Total debit value on stock input account should be equal to the original PO price of the product.")
- self.assertAlmostEquals(sum(input_aml.mapped('credit')), 110, "Total credit value on stock input account should be equal to the original PO price of the product.")
+ self.assertEqual(len(input_aml), 3, "Only two lines should have been generated in stock input account: one when receiving the product, two when making the invoice.")
+ self.assertAlmostEqual(sum(input_aml.mapped('debit')), 110, "Total debit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(input_aml.mapped('credit')), 110, "Total credit value on stock input account should be equal to the original PO price of the product.")
def test_anglosaxon_valuation_discount(self):
"""
@@ -1254,14 +1254,14 @@ class TestStockValuationWithCOA(AccountingTestCase):
# Check what was posted in the price difference account
price_diff_aml = self.env['account.move.line'].search([('account_id', '=', self.price_diff_account.id)])
- self.assertEquals(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
- self.assertAlmostEquals(price_diff_aml.credit, 10, "Price difference should be equal to 10 (100-90)")
+ self.assertEqual(len(price_diff_aml), 1, "Only one line should have been generated in the price difference account.")
+ self.assertAlmostEqual(price_diff_aml.credit, 10, "Price difference should be equal to 10 (100-90)")
# Check what was posted in stock input account
input_aml = self.env['account.move.line'].search([('account_id', '=', self.stock_input_account.id)])
- self.assertEquals(len(input_aml), 3, "Three lines generated in stock input account: one when receiving the product, two when making the invoice.")
- self.assertAlmostEquals(sum(input_aml.mapped('debit')), 100, "Total debit value on stock input account should be equal to the original PO price of the product.")
- self.assertAlmostEquals(sum(input_aml.mapped('credit')), 100, "Total credit value on stock input account should be equal to the original PO price of the product.")
+ self.assertEqual(len(input_aml), 3, "Three lines generated in stock input account: one when receiving the product, two when making the invoice.")
+ self.assertAlmostEqual(sum(input_aml.mapped('debit')), 100, "Total debit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(input_aml.mapped('credit')), 100, "Total credit value on stock input account should be equal to the original PO price of the product.")
def test_anglosaxon_valuation_price_unit_diff_discount(self):
"""
@@ -1301,10 +1301,10 @@ class TestStockValuationWithCOA(AccountingTestCase):
# Check if something was posted in the price difference account
price_diff_aml = self.env['account.move.line'].search([('account_id','=', self.price_diff_account.id)])
- self.assertEquals(len(price_diff_aml), 0, "No line should have been generated in the price difference account.")
+ self.assertEqual(len(price_diff_aml), 0, "No line should have been generated in the price difference account.")
# Check what was posted in stock input account
input_aml = self.env['account.move.line'].search([('account_id','=', self.stock_input_account.id)])
- self.assertEquals(len(input_aml), 2, "Only two lines should have been generated in stock input account: one when receiving the product, one when making the invoice.")
- self.assertAlmostEquals(sum(input_aml.mapped('debit')), 90, "Total debit value on stock input account should be equal to the original PO price of the product.")
- self.assertAlmostEquals(sum(input_aml.mapped('credit')), 90, "Total credit value on stock input account should be equal to the original PO price of the product.")
+ self.assertEqual(len(input_aml), 2, "Only two lines should have been generated in stock input account: one when receiving the product, one when making the invoice.")
+ self.assertAlmostEqual(sum(input_aml.mapped('debit')), 90, "Total debit value on stock input account should be equal to the original PO price of the product.")
+ self.assertAlmostEqual(sum(input_aml.mapped('credit')), 90, "Total credit value on stock input account should be equal to the original PO price of the product.")
diff --git a/addons/sale/tests/test_access_rights.py b/addons/sale/tests/test_access_rights.py
index 492ff640ce31..cc6f66556b1d 100644
--- a/addons/sale/tests/test_access_rights.py
+++ b/addons/sale/tests/test_access_rights.py
@@ -87,7 +87,7 @@ class TestAccessRights(TestCommonSaleNoChart):
self.assertIn(india_channel.id, self.env['crm.team'].search([]).ids, 'Sales manager should be able to create a Sales Team')
# Manager can edit a Sales Team
india_channel.with_user(self.user_manager).write({'name': 'new_india'})
- self.assertEquals(india_channel.name, 'new_india', 'Sales manager should be able to edit a Sales Team')
+ self.assertEqual(india_channel.name, 'new_india', 'Sales manager should be able to edit a Sales Team')
# Manager can delete a Sales Team
india_channel.with_user(self.user_manager).unlink()
self.assertNotIn(india_channel.id, self.env['crm.team'].search([]).ids, 'Sales manager should be able to delete a Sales Team')
diff --git a/addons/sale/tests/test_onchange.py b/addons/sale/tests/test_onchange.py
index 978cde5321a9..ffb2dbd09d2e 100644
--- a/addons/sale/tests/test_onchange.py
+++ b/addons/sale/tests/test_onchange.py
@@ -63,7 +63,7 @@ class TestOnchangeProductId(TransactionCase):
sale_order = order_form.save()
# Check the unit price of SO line
- self.assertEquals(100, sale_order.order_line[0].price_unit, "The included tax must be subtracted to the price")
+ self.assertEqual(100, sale_order.order_line[0].price_unit, "The included tax must be subtracted to the price")
def test_pricelist_application(self):
""" Test different prices are correctly applied based on dates """
@@ -102,7 +102,7 @@ class TestOnchangeProductId(TransactionCase):
so = order_form.save()
# Check the unit price and subtotal of SO line
self.assertEqual(so.order_line[0].price_unit, 80, "First date pricelist rule not applied")
- self.assertEquals(so.order_line[0].price_subtotal, so.order_line[0].price_unit * so.order_line[0].product_uom_qty, 'Total of SO line should be a multiplication of unit price and ordered quantity')
+ self.assertEqual(so.order_line[0].price_subtotal, so.order_line[0].price_unit * so.order_line[0].product_uom_qty, 'Total of SO line should be a multiplication of unit price and ordered quantity')
# Change order date of the SO and check the unit price and subtotal of SO line
with Form(so) as order:
@@ -111,7 +111,7 @@ class TestOnchangeProductId(TransactionCase):
line.product_id = support_product
self.assertEqual(so.order_line[0].price_unit, 50, "Second date pricelist rule not applied")
- self.assertEquals(so.order_line[0].price_subtotal, so.order_line[0].price_unit * so.order_line[0].product_uom_qty, 'Total of SO line should be a multiplication of unit price and ordered quantity')
+ self.assertEqual(so.order_line[0].price_subtotal, so.order_line[0].price_unit * so.order_line[0].product_uom_qty, 'Total of SO line should be a multiplication of unit price and ordered quantity')
def test_pricelist_uom_discount(self):
""" Test prices and discounts are correctly applied based on date and uom"""
diff --git a/addons/sale/tests/test_reinvoice.py b/addons/sale/tests/test_reinvoice.py
index b7640fd23e9e..0fb5747ecde1 100644
--- a/addons/sale/tests/test_reinvoice.py
+++ b/addons/sale/tests/test_reinvoice.py
@@ -78,17 +78,17 @@ class TestReInvoice(TestCommonSaleNoChart):
self.assertTrue(sale_order_line3, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line4, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
- self.assertEquals(sale_order_line2.qty_delivered, 1, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line2.qty_delivered, 1, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
- self.assertEquals((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_ordered_cost.standard_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_deliver_cost.standard_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_ordered_cost.standard_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_deliver_cost.standard_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
- self.assertEquals(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
+ self.assertEqual(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
+ self.assertEqual(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
# create second invoice lines and validate it
move_form = Form(self.AccountMove)
@@ -110,11 +110,11 @@ class TestReInvoice(TestCommonSaleNoChart):
self.assertTrue(sale_order_line5, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line6, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 6, "There should be still 4 lines on the SO, no new created")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 4, "There should be still 2 expenses lines on the SO")
+ self.assertEqual(len(self.sale_order.order_line), 6, "There should be still 4 lines on the SO, no new created")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 4, "There should be still 2 expenses lines on the SO")
- self.assertEquals((sale_order_line5.price_unit, sale_order_line5.qty_delivered, sale_order_line5.product_uom_qty, sale_order_line5.qty_invoiced), (self.product_ordered_cost.standard_price, 2, 0, 0), 'Sale line 5 is wrong after confirming 2e vendor invoice')
- self.assertEquals((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line6.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_deliver_cost.standard_price, 2, 0, 0), 'Sale line 6 is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line5.price_unit, sale_order_line5.qty_delivered, sale_order_line5.product_uom_qty, sale_order_line5.qty_invoiced), (self.product_ordered_cost.standard_price, 2, 0, 0), 'Sale line 5 is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line6.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_deliver_cost.standard_price, 2, 0, 0), 'Sale line 6 is wrong after confirming 2e vendor invoice')
def test_sales_price(self):
""" Test invoicing vendor bill at sales price for products based on delivered and ordered quantities. Check no existing SO line is incremented, but when invoicing a
@@ -163,17 +163,17 @@ class TestReInvoice(TestCommonSaleNoChart):
self.assertTrue(sale_order_line3, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line4, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
- self.assertEquals(sale_order_line2.qty_delivered, 1, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line2.qty_delivered, 1, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
- self.assertEquals((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_deliver_sales_price.list_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_order_sales_price.list_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_deliver_sales_price.list_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_order_sales_price.list_price, 3, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 3 should be computed by analytic amount")
- self.assertEquals(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 4 should be computed by analytic amount")
+ self.assertEqual(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 3 should be computed by analytic amount")
+ self.assertEqual(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 4 should be computed by analytic amount")
# create second invoice lines and validate it
move_form = Form(self.AccountMove)
@@ -195,10 +195,10 @@ class TestReInvoice(TestCommonSaleNoChart):
self.assertFalse(sale_order_line5, "No new sale line should have been created with delivered product !!")
self.assertTrue(sale_order_line6, "A new sale line should have been created with ordered product")
- self.assertEquals(len(self.sale_order.order_line), 5, "There should be 5 lines on the SO, 1 new created and 1 incremented")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 3, "There should be 3 expenses lines on the SO")
+ self.assertEqual(len(self.sale_order.order_line), 5, "There should be 5 lines on the SO, 1 new created and 1 incremented")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 3, "There should be 3 expenses lines on the SO")
- self.assertEquals((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_order_sales_price.list_price, 2, 0, 0), 'Sale line is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_order_sales_price.list_price, 2, 0, 0), 'Sale line is wrong after confirming 2e vendor invoice')
def test_no_expense(self):
""" Test invoicing vendor bill with no policy. Check nothing happen. """
@@ -229,6 +229,6 @@ class TestReInvoice(TestCommonSaleNoChart):
})
invoice_a.post()
- self.assertEquals(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) when validating vendor bill")
- self.assertEquals(sale_order_line.qty_delivered, 1, "The delivered quantity of SO line should not have been incremented")
+ self.assertEqual(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) when validating vendor bill")
+ self.assertEqual(sale_order_line.qty_delivered, 1, "The delivered quantity of SO line should not have been incremented")
self.assertTrue(invoice_a.mapped('line_ids.analytic_line_ids'), "Analytic lines should be generated")
diff --git a/addons/sale/tests/test_sale_order.py b/addons/sale/tests/test_sale_order.py
index 0b30a9c0aa0d..e491f7e5c877 100644
--- a/addons/sale/tests/test_sale_order.py
+++ b/addons/sale/tests/test_sale_order.py
@@ -212,7 +212,7 @@ class TestSaleOrder(TestCommonSaleNoChart):
inv.post()
sol = so.order_line.filtered(lambda l: l.product_id == serv_cost)
self.assertTrue(sol, 'Sale: cost invoicing does not add lines when confirming vendor invoice')
- self.assertEquals((sol.price_unit, sol.qty_delivered, sol.product_uom_qty, sol.qty_invoiced), (160, 2, 0, 0), 'Sale: line is wrong after confirming vendor invoice')
+ self.assertEqual((sol.price_unit, sol.qty_delivered, sol.product_uom_qty, sol.qty_invoiced), (160, 2, 0, 0), 'Sale: line is wrong after confirming vendor invoice')
def test_sale_with_taxes(self):
""" Test SO with taxes applied on its lines and check subtotal applied on its lines and total applied on the SO """
@@ -245,9 +245,9 @@ class TestSaleOrder(TestCommonSaleNoChart):
else:
price = line.price_unit * line.product_uom_qty
- self.assertEquals(float_compare(line.price_subtotal, price, precision_digits=2), 0)
+ self.assertEqual(float_compare(line.price_subtotal, price, precision_digits=2), 0)
- self.assertEquals(self.sale_order.amount_total,
+ self.assertEqual(self.sale_order.amount_total,
self.sale_order.amount_untaxed + self.sale_order.amount_tax,
'Taxes should be applied')
@@ -353,8 +353,8 @@ class TestSaleOrder(TestCommonSaleNoChart):
# Call again for st_line_2, it should find sale_order
res = self.env['account.reconciliation.widget'].get_bank_statement_line_data([st_line2.id])
line = res.get('lines', [{}])[0]
- self.assertEquals(line.get('sale_order_ids', []), [so.id])
+ self.assertEqual(line.get('sale_order_ids', []), [so.id])
# Call again for st_line_3, it should find sale_order based on reference
res = self.env['account.reconciliation.widget'].get_bank_statement_line_data([st_line3.id])
line = res.get('lines', [{}])[0]
- self.assertEquals(line.get('sale_order_ids', []), [so.id])
+ self.assertEqual(line.get('sale_order_ids', []), [so.id])
diff --git a/addons/sale/tests/test_sale_pricelist.py b/addons/sale/tests/test_sale_pricelist.py
index 3fc37a5a2a82..6f655db4eb08 100644
--- a/addons/sale/tests/test_sale_pricelist.py
+++ b/addons/sale/tests/test_sale_pricelist.py
@@ -125,7 +125,7 @@ class TestSaleOrder(TestCommonSaleNoChart):
line._onchange_discount()
# Check that pricelist of the SO has been applied on the sale order lines or not
for line in self.sale_order.order_line:
- self.assertEquals(line.price_unit, line.product_id.list_price, 'Pricelist of the SO should not be applied on an order line %s' % (line.name,))
+ self.assertEqual(line.price_unit, line.product_id.list_price, 'Pricelist of the SO should not be applied on an order line %s' % (line.name,))
def test_sale_with_pricelist_discount_included(self):
""" Test SO with the pricelist and check unit price appeared on its lines """
@@ -138,11 +138,11 @@ class TestSaleOrder(TestCommonSaleNoChart):
# Check that pricelist of the SO has been applied on the sale order lines or not
for line in self.sale_order.order_line:
if line.product_id == self.product_order:
- self.assertEquals(line.price_unit, self.pricelist_discount_incl_item3.fixed_price, 'Price of product_order should be %s applied on the order line' % (self.pricelist_discount_incl_item3.fixed_price,))
+ self.assertEqual(line.price_unit, self.pricelist_discount_incl_item3.fixed_price, 'Price of product_order should be %s applied on the order line' % (self.pricelist_discount_incl_item3.fixed_price,))
else: # only services (service_order and service_deliver)
for item in self.sale_order.pricelist_id.item_ids.filtered(lambda l: l.product_tmpl_id == line.product_id.product_tmpl_id):
price = item.percent_price
- self.assertEquals(price, (line.product_id.list_price - line.price_unit) / line.product_id.list_price * 100, 'Pricelist of the SO should be applied on an order line %s' % (line.product_id.name,))
+ self.assertEqual(price, (line.product_id.list_price - line.price_unit) / line.product_id.list_price * 100, 'Pricelist of the SO should be applied on an order line %s' % (line.product_id.name,))
def test_sale_with_pricelist_discount_excluded(self):
""" Test SO with the pricelist 'discount displayed' and check discount and unit price appeared on its lines """
@@ -164,12 +164,12 @@ class TestSaleOrder(TestCommonSaleNoChart):
for line in self.sale_order.order_line:
if line.product_id.categ_id in self.sale_order.pricelist_id.item_ids.mapped('categ_id'): # reduction per category (consummable only)
for item in self.sale_order.pricelist_id.item_ids.filtered(lambda l: l.categ_id == line.product_id.categ_id):
- self.assertEquals(line.discount, item.price_discount, "Discount should be displayed on order line %s since its category get some discount" % (line.name,))
- self.assertEquals(line.price_unit, line.product_id.standard_price, "Price unit should be the cost price for product %s" % (line.name,))
+ self.assertEqual(line.discount, item.price_discount, "Discount should be displayed on order line %s since its category get some discount" % (line.name,))
+ self.assertEqual(line.price_unit, line.product_id.standard_price, "Price unit should be the cost price for product %s" % (line.name,))
else:
if line.product_id == self.service_order: # reduction for this product
- self.assertEquals(line.discount, 20.0, "Discount for product %s should be 20 percent with pricelist %s" % (line.name, self.pricelist_discount_excl.name))
- self.assertEquals(line.price_unit, line.product_id.list_price, 'Unit price of order line should be a sale price as the pricelist not applied on the other category\'s product')
+ self.assertEqual(line.discount, 20.0, "Discount for product %s should be 20 percent with pricelist %s" % (line.name, self.pricelist_discount_excl.name))
+ self.assertEqual(line.price_unit, line.product_id.list_price, 'Unit price of order line should be a sale price as the pricelist not applied on the other category\'s product')
else: # no discount for the rest
- self.assertEquals(line.discount, 0.0, 'Pricelist of SO should not be applied on an order line')
- self.assertEquals(line.price_unit, line.product_id.list_price, 'Unit price of order line should be a sale price as the pricelist not applied on the other category\'s product')
+ self.assertEqual(line.discount, 0.0, 'Pricelist of SO should not be applied on an order line')
+ self.assertEqual(line.price_unit, line.product_id.list_price, 'Unit price of order line should be a sale price as the pricelist not applied on the other category\'s product')
diff --git a/addons/sale/tests/test_sale_refund.py b/addons/sale/tests/test_sale_refund.py
index 07446ec33a1b..5788ed2a648d 100644
--- a/addons/sale/tests/test_sale_refund.py
+++ b/addons/sale/tests/test_sale_refund.py
@@ -83,21 +83,21 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# Check quantity to invoice on SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered qty are not invoiced, so they should not be linked to invoice line")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 0.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 5.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
+ self.assertEqual(line.qty_to_invoice, 0.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 5.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
else:
- self.assertEquals(line.qty_to_invoice, 0.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 3.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
- self.assertEquals(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
+ self.assertEqual(line.qty_to_invoice, 0.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 3.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
# Make a credit note
credit_note_wizard = self.env['account.move.reversal'].with_context({'active_ids': [self.invoice.id], 'active_id': self.invoice.id}).create({
@@ -108,58 +108,58 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
invoice_refund = self.sale_order.invoice_ids.sorted(key=lambda inv: inv.id, reverse=False)[-1] # the first invoice, its refund, and the new invoice
# Check invoice's type and number
- self.assertEquals(invoice_refund.type, 'out_refund', 'The last created invoiced should be a refund')
- self.assertEquals(invoice_refund.state, 'draft', 'Last Customer invoices should be in draft')
- self.assertEquals(self.sale_order.invoice_count, 2, "The SO should have 2 related invoices: the original, the new refund")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 1, "The SO should be linked to only one customer invoices")
+ self.assertEqual(invoice_refund.type, 'out_refund', 'The last created invoiced should be a refund')
+ self.assertEqual(invoice_refund.state, 'draft', 'Last Customer invoices should be in draft')
+ self.assertEqual(self.sale_order.invoice_count, 2, "The SO should have 2 related invoices: the original, the new refund")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 1, "The SO should be linked to only one customer invoices")
# At this time, the invoice 1 is opend (validated) and its refund is in draft, so the amounts invoiced are not zero for
# invoiced sale line. The amounts only take validated invoice/refund into account.
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO line based on delivered qty")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO line based on delivered qty")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered are not invoiced, so they should not be linked to invoice line")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 5.0, "As the refund is created, the invoiced quantity cancel each other (consu ordered)")
- self.assertEquals(line.qty_invoiced, 0.0, "The qty to invoice should have decreased as the refund is created for ordered consu SO line")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "Amount to invoice is zero as the refund is not validated")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * 5, "Amount invoiced is now set as unit price * ordered qty - refund qty) even if the ")
- self.assertEquals(len(line.invoice_lines), 2, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 5.0, "As the refund is created, the invoiced quantity cancel each other (consu ordered)")
+ self.assertEqual(line.qty_invoiced, 0.0, "The qty to invoice should have decreased as the refund is created for ordered consu SO line")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "Amount to invoice is zero as the refund is not validated")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * 5, "Amount invoiced is now set as unit price * ordered qty - refund qty) even if the ")
+ self.assertEqual(len(line.invoice_lines), 2, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
else:
- self.assertEquals(line.qty_to_invoice, 3.0, "As the refund is created, the invoiced quantity cancel each other (consu ordered)")
- self.assertEquals(line.qty_invoiced, 0.0, "The qty to invoice should have decreased as the refund is created for ordered service SO line")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "Amount to invoice is zero as the refund is not validated")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * 3, "Amount invoiced is now set as unit price * ordered qty - refund qty) even if the ")
- self.assertEquals(len(line.invoice_lines), 2, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 3.0, "As the refund is created, the invoiced quantity cancel each other (consu ordered)")
+ self.assertEqual(line.qty_invoiced, 0.0, "The qty to invoice should have decreased as the refund is created for ordered service SO line")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "Amount to invoice is zero as the refund is not validated")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * 3, "Amount invoiced is now set as unit price * ordered qty - refund qty) even if the ")
+ self.assertEqual(len(line.invoice_lines), 2, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
# Validate the refund
invoice_refund.post()
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered are not invoiced, so they should not be linked to invoice line")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 5.0, "As the refund still exists, the quantity to invoice is the ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "The qty to invoice should be zero as, with the refund, the quantities cancel each other")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * 5, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, as refund is validated")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "Amount invoiced decreased as the refund is now confirmed")
- self.assertEquals(len(line.invoice_lines), 2, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 5.0, "As the refund still exists, the quantity to invoice is the ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "The qty to invoice should be zero as, with the refund, the quantities cancel each other")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * 5, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, as refund is validated")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "Amount invoiced decreased as the refund is now confirmed")
+ self.assertEqual(len(line.invoice_lines), 2, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
else:
- self.assertEquals(line.qty_to_invoice, 3.0, "As the refund still exists, the quantity to invoice is the ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "The qty to invoice should be zero as, with the refund, the quantities cancel each other")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * 3, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, as refund is validated")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "Amount invoiced decreased as the refund is now confirmed")
- self.assertEquals(len(line.invoice_lines), 2, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 3.0, "As the refund still exists, the quantity to invoice is the ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "The qty to invoice should be zero as, with the refund, the quantities cancel each other")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * 3, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, as refund is validated")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "Amount invoiced decreased as the refund is now confirmed")
+ self.assertEqual(len(line.invoice_lines), 2, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund)")
def test_refund_cancel(self):
""" Test invoice with a refund in 'cancel' mode, meaning a refund will be created and auto confirm to completely cancel the first
@@ -177,18 +177,18 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# Check quantity to invoice on SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered qty are not invoiced, so they should not be linked to invoice line")
else:
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
- self.assertEquals(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
- self.assertEquals(line.qty_invoiced, line.product_uom_qty + 1, "The quantity invoiced is +1 unit from the one of the sale line, as we modified invoice lines (%s)" % (line.name,))
- self.assertEquals(line.qty_to_invoice, -1, "The quantity to invoice is negative as we invoice more than ordered")
+ self.assertEqual(line.qty_invoiced, line.product_uom_qty + 1, "The quantity invoiced is +1 unit from the one of the sale line, as we modified invoice lines (%s)" % (line.name,))
+ self.assertEqual(line.qty_to_invoice, -1, "The quantity to invoice is negative as we invoice more than ordered")
# Make a credit note
credit_note_wizard = self.env['account.move.reversal'].with_context({'active_ids': self.invoice.ids, 'active_id': self.invoice.id}).create({
@@ -198,28 +198,28 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
invoice_refund = self.env['account.move'].browse(credit_note_wizard.reverse_moves()['res_id'])
# Check invoice's type and number
- self.assertEquals(invoice_refund.type, 'out_refund', 'The last created invoiced should be a customer invoice')
- self.assertEquals(invoice_refund.invoice_payment_state, 'paid', 'Last Customer creadit note should be in paid state')
- self.assertEquals(self.sale_order.invoice_count, 2, "The SO should have 3 related invoices: the original, the refund, and the new one")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 1, "The SO should be linked to only one customer invoices")
+ self.assertEqual(invoice_refund.type, 'out_refund', 'The last created invoiced should be a customer invoice')
+ self.assertEqual(invoice_refund.invoice_payment_state, 'paid', 'Last Customer creadit note should be in paid state')
+ self.assertEqual(self.sale_order.invoice_count, 2, "The SO should have 3 related invoices: the original, the refund, and the new one")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 1, "The SO should be linked to only one customer invoices")
# At this time, the invoice 1 is opened (validated) and its refund validated too, so the amounts invoiced are zero for
# all sale line. All invoiceable Sale lines have
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO line based on delivered qty")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO line based on delivered qty")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered are not invoiced, so they should not be linked to invoice line")
else:
- self.assertEquals(line.qty_to_invoice, line.product_uom_qty, "The quantity to invoice should be the ordered quantity")
- self.assertEquals(line.qty_invoiced, 0, "The quantity invoiced is zero as the refund (paid) completely cancel the first invoice")
+ self.assertEqual(line.qty_to_invoice, line.product_uom_qty, "The quantity to invoice should be the ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0, "The quantity invoiced is zero as the refund (paid) completely cancel the first invoice")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
- self.assertEquals(len(line.invoice_lines), 2, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(len(line.invoice_lines), 2, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
def test_refund_modify(self):
""" Test invoice with a refund in 'modify' mode, and check customer invoices credit note is created from respective invoice """
@@ -236,21 +236,21 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# Check quantity to invoice on SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered qty are not invoiced, so they should not be linked to invoice line")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 2.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 3.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
+ self.assertEqual(line.qty_to_invoice, 2.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 3.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
else:
- self.assertEquals(line.qty_to_invoice, 1.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 2.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
- self.assertEquals(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
+ self.assertEqual(line.qty_to_invoice, 1.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 2.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(len(line.invoice_lines), 1, "The lines 'ordered' qty are invoiced, so it should be linked to 1 invoice lines")
# Make a credit note
credit_note_wizard = self.env['account.move.reversal'].with_context({'active_ids': [self.invoice.id], 'active_id': self.invoice.id}).create({
@@ -260,34 +260,34 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
invoice_refund = self.env['account.move'].browse(credit_note_wizard.reverse_moves()['res_id'])
# Check invoice's type and number
- self.assertEquals(invoice_refund.type, 'out_invoice', 'The last created invoiced should be a customer invoice')
- self.assertEquals(invoice_refund.state, 'draft', 'Last Customer invoices should be in draft')
- self.assertEquals(self.sale_order.invoice_count, 3, "The SO should have 3 related invoices: the original, the refund, and the new one")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
- self.assertEquals(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 2, "The SO should be linked to two customer invoices")
+ self.assertEqual(invoice_refund.type, 'out_invoice', 'The last created invoiced should be a customer invoice')
+ self.assertEqual(invoice_refund.state, 'draft', 'Last Customer invoices should be in draft')
+ self.assertEqual(self.sale_order.invoice_count, 3, "The SO should have 3 related invoices: the original, the refund, and the new one")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_refund')), 1, "The SO should be linked to only one refund")
+ self.assertEqual(len(self.sale_order.invoice_ids.filtered(lambda inv: inv.type == 'out_invoice')), 2, "The SO should be linked to two customer invoices")
# At this time, the invoice 1 and its refund are confirmed, so the amounts invoiced are zero. The third invoice
# (2nd customer inv) is in draft state.
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered are not invoiced, so they should not be linked to invoice line")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 2.0, "The qty to invoice does not change when confirming the new invoice (2)")
- self.assertEquals(line.qty_invoiced, 3.0, "The ordered (prod) sale line does not change on invoice 2 confirmation")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * 5, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "Amount invoiced is zero as the invoice 1 and its refund are reconcilied")
- self.assertEquals(len(line.invoice_lines), 3, "The line 'ordered consumable' is invoiced, so it should be linked to 3 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 2.0, "The qty to invoice does not change when confirming the new invoice (2)")
+ self.assertEqual(line.qty_invoiced, 3.0, "The ordered (prod) sale line does not change on invoice 2 confirmation")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * 5, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "Amount invoiced is zero as the invoice 1 and its refund are reconcilied")
+ self.assertEqual(len(line.invoice_lines), 3, "The line 'ordered consumable' is invoiced, so it should be linked to 3 invoice lines (invoice and refund)")
else:
- self.assertEquals(line.qty_to_invoice, 1.0, "The qty to invoice does not change when confirming the new invoice (2)")
- self.assertEquals(line.qty_invoiced, 2.0, "The ordered (serv) sale line does not change on invoice 2 confirmation")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * 3, "Amount to invoice is now set as unit price * ordered qty - refund qty) even if the ")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "Amount invoiced is zero as the invoice 1 and its refund are reconcilied")
- self.assertEquals(len(line.invoice_lines), 3, "The line 'ordered service' is invoiced, so it should be linked to 3 invoice lines (invoice and refund)")
+ self.assertEqual(line.qty_to_invoice, 1.0, "The qty to invoice does not change when confirming the new invoice (2)")
+ self.assertEqual(line.qty_invoiced, 2.0, "The ordered (serv) sale line does not change on invoice 2 confirmation")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * 3, "Amount to invoice is now set as unit price * ordered qty - refund qty) even if the ")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "Amount invoiced is zero as the invoice 1 and its refund are reconcilied")
+ self.assertEqual(len(line.invoice_lines), 3, "The line 'ordered service' is invoiced, so it should be linked to 3 invoice lines (invoice and refund)")
# Change unit of ordered product on refund lines
move_form = Form(invoice_refund)
@@ -302,21 +302,21 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
self.assertFalse(line.invoice_lines, "The line based on delivered are not invoiced, so they should not be linked to invoice line, even after validation")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 2.0, "The qty to invoice does not change when confirming the new invoice (3)")
- self.assertEquals(line.qty_invoiced, 3.0, "The ordered sale line are totally invoiced (qty invoiced = ordered qty)")
- self.assertEquals(line.untaxed_amount_to_invoice, 1100.0, "")
- self.assertEquals(line.untaxed_amount_invoiced, 300.0, "")
- self.assertEquals(len(line.invoice_lines), 3, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund), even after validation")
+ self.assertEqual(line.qty_to_invoice, 2.0, "The qty to invoice does not change when confirming the new invoice (3)")
+ self.assertEqual(line.qty_invoiced, 3.0, "The ordered sale line are totally invoiced (qty invoiced = ordered qty)")
+ self.assertEqual(line.untaxed_amount_to_invoice, 1100.0, "")
+ self.assertEqual(line.untaxed_amount_invoiced, 300.0, "")
+ self.assertEqual(len(line.invoice_lines), 3, "The line 'ordered consumable' is invoiced, so it should be linked to 2 invoice lines (invoice and refund), even after validation")
else:
- self.assertEquals(line.qty_to_invoice, 1.0, "The qty to invoice does not change when confirming the new invoice (3)")
- self.assertEquals(line.qty_invoiced, 2.0, "The ordered sale line are totally invoiced (qty invoiced = ordered qty)")
- self.assertEquals(line.untaxed_amount_to_invoice, 170.0, "")
- self.assertEquals(line.untaxed_amount_invoiced, 100.0, "")
- self.assertEquals(len(line.invoice_lines), 3, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund), even after validation")
+ self.assertEqual(line.qty_to_invoice, 1.0, "The qty to invoice does not change when confirming the new invoice (3)")
+ self.assertEqual(line.qty_invoiced, 2.0, "The ordered sale line are totally invoiced (qty invoiced = ordered qty)")
+ self.assertEqual(line.untaxed_amount_to_invoice, 170.0, "")
+ self.assertEqual(line.untaxed_amount_invoiced, 100.0, "")
+ self.assertEqual(len(line.invoice_lines), 3, "The line 'ordered service' is invoiced, so it should be linked to 2 invoice lines (invoice and refund), even after validation")
diff --git a/addons/sale/tests/test_sale_to_invoice.py b/addons/sale/tests/test_sale_to_invoice.py
index 5df778af1fe7..a67158a3d118 100644
--- a/addons/sale/tests/test_sale_to_invoice.py
+++ b/addons/sale/tests/test_sale_to_invoice.py
@@ -83,9 +83,9 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
})
payment.create_invoices()
- self.assertEquals(len(self.sale_order.invoice_ids), 1, 'Invoice should be created for the SO')
+ self.assertEqual(len(self.sale_order.invoice_ids), 1, 'Invoice should be created for the SO')
downpayment_line = self.sale_order.order_line.filtered(lambda l: l.is_downpayment)
- self.assertEquals(len(downpayment_line), 1, 'SO line downpayment should be created on SO')
+ self.assertEqual(len(downpayment_line), 1, 'SO line downpayment should be created on SO')
# Update delivered quantity of SO lines
self.sol_serv_deliver.write({'qty_delivered': 4.0})
@@ -97,11 +97,11 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
})
payment.create_invoices()
- self.assertEquals(len(self.sale_order.invoice_ids), 2, 'Invoice should be created for the SO')
+ self.assertEqual(len(self.sale_order.invoice_ids), 2, 'Invoice should be created for the SO')
invoice = self.sale_order.invoice_ids.sorted()[0]
- self.assertEquals(len(invoice.invoice_line_ids), len(self.sale_order.order_line), 'All lines should be invoiced')
- self.assertEquals(invoice.amount_total, self.sale_order.amount_total - downpayment_line.price_unit, 'Downpayment should be applied')
+ self.assertEqual(len(invoice.invoice_line_ids), len(self.sale_order.order_line), 'All lines should be invoiced')
+ self.assertEqual(invoice.amount_total, self.sale_order.amount_total - downpayment_line.price_unit, 'Downpayment should be applied')
def test_invoice_with_discount(self):
""" Test invoice with a discount and check discount applied on both SO lines and an invoice lines """
@@ -113,7 +113,7 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
for line in self.sale_order.order_line.filtered(lambda l: l.discount):
product_price = line.price_unit * line.product_uom_qty
- self.assertEquals(line.discount, (product_price - line.price_subtotal) / product_price * 100, 'Discount should be applied on order line')
+ self.assertEqual(line.discount, (product_price - line.price_subtotal) / product_price * 100, 'Discount should be applied on order line')
# lines are in draft
for line in self.sale_order.order_line:
@@ -125,9 +125,9 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
for line in self.sale_order.order_line:
self.assertTrue(float_is_zero(line.untaxed_amount_invoiced, precision_digits=2), "The invoiced amount should be zero, as the line is in draft state")
- self.assertEquals(self.sol_serv_order.untaxed_amount_to_invoice, 297, "The untaxed amount to invoice is wrong")
- self.assertEquals(self.sol_serv_deliver.untaxed_amount_to_invoice, self.sol_serv_deliver.qty_delivered * self.sol_serv_deliver.price_reduce, "The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)")
- self.assertEquals(self.sol_prod_deliver.untaxed_amount_to_invoice, 140, "The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)")
+ self.assertEqual(self.sol_serv_order.untaxed_amount_to_invoice, 297, "The untaxed amount to invoice is wrong")
+ self.assertEqual(self.sol_serv_deliver.untaxed_amount_to_invoice, self.sol_serv_deliver.qty_delivered * self.sol_serv_deliver.price_reduce, "The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)")
+ self.assertEqual(self.sol_prod_deliver.untaxed_amount_to_invoice, 140, "The untaxed amount to invoice should be qty deli * price reduce, so 4 * (180 - 36)")
# Let's do an invoice with invoiceable lines
payment = self.env['sale.advance.payment.inv'].with_context(self.context).create({
@@ -139,7 +139,7 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# Check discount appeared on both SO lines and invoice lines
for line, inv_line in zip(self.sale_order.order_line, invoice.invoice_line_ids):
- self.assertEquals(line.discount, inv_line.discount, 'Discount on lines of order and invoice should be same')
+ self.assertEqual(line.discount, inv_line.discount, 'Discount on lines of order and invoice should be same')
def test_invoice(self):
""" Test create and invoice from the SO, and check qty invoice/to invoice, and the related amounts """
@@ -154,15 +154,15 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# Check ordered quantity, quantity to invoice and invoiced quantity of SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, 'Quantity to invoice should be same as ordered quantity')
- self.assertEquals(line.qty_invoiced, 0.0, 'Invoiced quantity should be zero as no any invoice created for SO')
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, 'Quantity to invoice should be same as ordered quantity')
+ self.assertEqual(line.qty_invoiced, 0.0, 'Invoiced quantity should be zero as no any invoice created for SO')
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
else:
- self.assertEquals(line.qty_to_invoice, line.product_uom_qty, 'Quantity to invoice should be same as ordered quantity')
- self.assertEquals(line.qty_invoiced, 0.0, 'Invoiced quantity should be zero as no any invoice created for SO')
- self.assertEquals(line.untaxed_amount_to_invoice, line.product_uom_qty * line.price_unit, "The amount to invoice should the total of the line, as the line is confirmed")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line is confirmed")
+ self.assertEqual(line.qty_to_invoice, line.product_uom_qty, 'Quantity to invoice should be same as ordered quantity')
+ self.assertEqual(line.qty_invoiced, 0.0, 'Invoiced quantity should be zero as no any invoice created for SO')
+ self.assertEqual(line.untaxed_amount_to_invoice, line.product_uom_qty * line.price_unit, "The amount to invoice should the total of the line, as the line is confirmed")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line is confirmed")
# Let's do an invoice with invoiceable lines
payment = self.env['sale.advance.payment.inv'].with_context(self.context).create({
@@ -183,35 +183,35 @@ class TestSaleToInvoice(TestCommonSaleNoChart):
# amount to invoice / invoiced should not have changed (amounts take only confirmed invoice into account)
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be zero")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as delivered lines are not delivered yet")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity (no confirmed invoice)")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as no invoice are validated for now")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be zero")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as delivered lines are not delivered yet")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity (no confirmed invoice)")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as no invoice are validated for now")
else:
if line == self.sol_prod_order:
- self.assertEquals(self.sol_prod_order.qty_to_invoice, 2.0, "Changing the quantity on draft invoice update the qty to invoice on SO lines")
- self.assertEquals(self.sol_prod_order.qty_invoiced, 3.0, "Changing the quantity on draft invoice update the invoiced qty on SO lines")
+ self.assertEqual(self.sol_prod_order.qty_to_invoice, 2.0, "Changing the quantity on draft invoice update the qty to invoice on SO lines")
+ self.assertEqual(self.sol_prod_order.qty_invoiced, 3.0, "Changing the quantity on draft invoice update the invoiced qty on SO lines")
else:
- self.assertEquals(self.sol_serv_order.qty_to_invoice, 1.0, "Changing the quantity on draft invoice update the qty to invoice on SO lines")
- self.assertEquals(self.sol_serv_order.qty_invoiced, 2.0, "Changing the quantity on draft invoice update the invoiced qty on SO lines")
- self.assertEquals(line.untaxed_amount_to_invoice, line.product_uom_qty * line.price_unit, "The amount to invoice should the total of the line, as the line is confirmed (no confirmed invoice)")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as no invoice are validated for now")
+ self.assertEqual(self.sol_serv_order.qty_to_invoice, 1.0, "Changing the quantity on draft invoice update the qty to invoice on SO lines")
+ self.assertEqual(self.sol_serv_order.qty_invoiced, 2.0, "Changing the quantity on draft invoice update the invoiced qty on SO lines")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.product_uom_qty * line.price_unit, "The amount to invoice should the total of the line, as the line is confirmed (no confirmed invoice)")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as no invoice are validated for now")
invoice.post()
# Check quantity to invoice on SO lines
for line in self.sale_order.order_line:
if line.product_id.invoice_policy == 'delivery':
- self.assertEquals(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
- self.assertEquals(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
- self.assertEquals(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
- self.assertEquals(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.qty_to_invoice, 0.0, "Quantity to invoice should be same as ordered quantity")
+ self.assertEqual(line.qty_invoiced, 0.0, "Invoiced quantity should be zero as no any invoice created for SO")
+ self.assertEqual(line.untaxed_amount_to_invoice, 0.0, "The amount to invoice should be zero, as the line based on delivered quantity")
+ self.assertEqual(line.untaxed_amount_invoiced, 0.0, "The invoiced amount should be zero, as the line based on delivered quantity")
else:
if line == self.sol_prod_order:
- self.assertEquals(line.qty_to_invoice, 2.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 3.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
+ self.assertEqual(line.qty_to_invoice, 2.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 3.0, "The ordered (prod) sale line are totally invoiced (qty invoiced come from the invoice lines)")
else:
- self.assertEquals(line.qty_to_invoice, 1.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
- self.assertEquals(line.qty_invoiced, 2.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
- self.assertEquals(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
- self.assertEquals(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.qty_to_invoice, 1.0, "The ordered sale line are totally invoiced (qty to invoice is zero)")
+ self.assertEqual(line.qty_invoiced, 2.0, "The ordered (serv) sale line are totally invoiced (qty invoiced = the invoice lines)")
+ self.assertEqual(line.untaxed_amount_to_invoice, line.price_unit * line.qty_to_invoice, "Amount to invoice is now set as qty to invoice * unit price since no price change on invoice, for ordered products")
+ self.assertEqual(line.untaxed_amount_invoiced, line.price_unit * line.qty_invoiced, "Amount invoiced is now set as qty invoiced * unit price since no price change on invoice, for ordered products")
diff --git a/addons/sale_expense/tests/test_reinvoice.py b/addons/sale_expense/tests/test_reinvoice.py
index 0a7fa507c53f..bae15f230178 100644
--- a/addons/sale_expense/tests/test_reinvoice.py
+++ b/addons/sale_expense/tests/test_reinvoice.py
@@ -74,24 +74,24 @@ class TestReInvoice(TestExpenseCommon, TestCommonSaleNoChart):
self.expense_sheet.approve_expense_sheets()
self.expense_sheet.action_sheet_move_create()
- self.assertEquals(len(self.sale_order.order_line), 3, "There should be 3 lines on the SO")
- self.assertEquals(sale_order_line.qty_delivered, 0, "Exising SO line should not be impacted by reinvoicing product at cost")
+ self.assertEqual(len(self.sale_order.order_line), 3, "There should be 3 lines on the SO")
+ self.assertEqual(sale_order_line.qty_delivered, 0, "Exising SO line should not be impacted by reinvoicing product at cost")
sol_ordered = self.sale_order.order_line.filtered(lambda sol: sol.product_id == self.product_ordered_cost and sol != sale_order_line)
self.assertTrue(sol_ordered.is_expense, "The new SOL should be flag as coming from an expense")
- self.assertEquals(sol_ordered.qty_delivered_method, 'analytic', 'Delivered quantity of expense SO line should be computed by analytic amount')
+ self.assertEqual(sol_ordered.qty_delivered_method, 'analytic', 'Delivered quantity of expense SO line should be computed by analytic amount')
self.assertTrue(sol_ordered, "A new line with ordered expense should have been created on expense report posting")
- self.assertEquals(sol_ordered.price_unit, expense1.unit_amount, "The unit price of new SO line should be the one from the expense (at cost)")
- self.assertEquals(sol_ordered.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
- self.assertEquals(sol_ordered.qty_delivered, expense1.quantity, "The delivered quantity of new SO line should be the one from the expense")
+ self.assertEqual(sol_ordered.price_unit, expense1.unit_amount, "The unit price of new SO line should be the one from the expense (at cost)")
+ self.assertEqual(sol_ordered.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
+ self.assertEqual(sol_ordered.qty_delivered, expense1.quantity, "The delivered quantity of new SO line should be the one from the expense")
sol_deliver = self.sale_order.order_line.filtered(lambda sol: sol.product_id == self.product_deliver_cost and sol != sale_order_line)
self.assertTrue(sol_deliver.is_expense, "The new SOL should be flag as coming from an expense")
- self.assertEquals(sol_deliver.qty_delivered_method, 'analytic', 'Delivered quantity of expense SO line should be computed by analytic amount')
+ self.assertEqual(sol_deliver.qty_delivered_method, 'analytic', 'Delivered quantity of expense SO line should be computed by analytic amount')
self.assertTrue(sol_deliver, "A new line with delivered expense should have been created on expense report posting")
- self.assertEquals(sol_deliver.price_unit, expense2.unit_amount, "The unit price of new SO line should be the one from the expense (at cost)")
- self.assertEquals(sol_deliver.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
- self.assertEquals(sol_deliver.qty_delivered, expense2.quantity, "The delivered quantity of new SO line should be the one from the expense")
+ self.assertEqual(sol_deliver.price_unit, expense2.unit_amount, "The unit price of new SO line should be the one from the expense (at cost)")
+ self.assertEqual(sol_deliver.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
+ self.assertEqual(sol_deliver.qty_delivered, expense2.quantity, "The delivered quantity of new SO line should be the one from the expense")
def test_sales_price_ordered(self):
""" Test invoicing expenses at sales price for product based on ordered quantities. """
@@ -118,15 +118,15 @@ class TestReInvoice(TestExpenseCommon, TestCommonSaleNoChart):
self.expense_sheet.action_sheet_move_create()
self.assertTrue(self.sale_order.analytic_account_id, "Posting expense with an expense product should trigger the analytic account creation on SO")
- self.assertEquals(self.sale_order.analytic_account_id, expense1.analytic_account_id, "SO analytic account should be the same for the expense")
- self.assertEquals(len(self.sale_order.order_line), 1, "A new So line should have been created on expense report posting")
+ self.assertEqual(self.sale_order.analytic_account_id, expense1.analytic_account_id, "SO analytic account should be the same for the expense")
+ self.assertEqual(len(self.sale_order.order_line), 1, "A new So line should have been created on expense report posting")
sol_ordered = self.sale_order.order_line.filtered(lambda sol: sol.product_id == expense1.product_id)
self.assertTrue(sol_ordered.is_expense, "The new SOL should be flag as coming from an expense")
self.assertTrue(sol_ordered, "A new line with ordered expense should have been created on expense report posting")
- self.assertEquals(sol_ordered.price_unit, 10, "The unit price of new SO line should be the one from the expense (at sales price)")
- self.assertEquals(sol_ordered.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
- self.assertEquals(sol_ordered.qty_delivered, expense1.quantity, "The delivered quantity of new SO line should be the one from the expense")
+ self.assertEqual(sol_ordered.price_unit, 10, "The unit price of new SO line should be the one from the expense (at sales price)")
+ self.assertEqual(sol_ordered.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
+ self.assertEqual(sol_ordered.qty_delivered, expense1.quantity, "The delivered quantity of new SO line should be the one from the expense")
def test_sales_price_delivered(self):
""" Test invoicing expenses at sales price for product based on delivered quantities. Check the existing SO line is not incremented, but a new
@@ -164,13 +164,13 @@ class TestReInvoice(TestExpenseCommon, TestCommonSaleNoChart):
self.expense_sheet.approve_expense_sheets()
self.expense_sheet.action_sheet_move_create()
- self.assertEquals(len(self.sale_order.order_line), 2, "A new expense SOL should have been created.")
+ self.assertEqual(len(self.sale_order.order_line), 2, "A new expense SOL should have been created.")
sale_order_line2 = self.sale_order.order_line.filtered(lambda sol: sol != sale_order_line1)
self.assertTrue(sale_order_line2.is_expense, "The new SOL should be flag as coming from an expense")
- self.assertEquals(sale_order_line2.price_unit, 10, "The unit price of SO line should be the same")
- self.assertEquals(sale_order_line2.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
- self.assertEquals(sale_order_line2.qty_delivered, expense1.quantity, "The delivered quantity of SO line should have be the same of the expense")
+ self.assertEqual(sale_order_line2.price_unit, 10, "The unit price of SO line should be the same")
+ self.assertEqual(sale_order_line2.product_uom_qty, 0, "The ordered quantity of new SO line should be zero")
+ self.assertEqual(sale_order_line2.qty_delivered, expense1.quantity, "The delivered quantity of SO line should have be the same of the expense")
# create 2nd expense lines
expense2 = self.env['hr.expense'].create({
@@ -189,11 +189,11 @@ class TestReInvoice(TestExpenseCommon, TestCommonSaleNoChart):
self.expense_sheet2.approve_expense_sheets()
self.expense_sheet2.action_sheet_move_create()
- self.assertEquals(len(self.sale_order.order_line), 2, "No new expense SOL should have been created.")
+ self.assertEqual(len(self.sale_order.order_line), 2, "No new expense SOL should have been created.")
- self.assertEquals(sale_order_line2.price_unit, 10, "The unit price of SO line should be the same")
- self.assertEquals(sale_order_line2.product_uom_qty, 0, "The ordered quantity of new SO line should remains zero")
- self.assertEquals(sale_order_line2.qty_delivered, expense1.quantity + expense2.quantity, "The delivered quantity of SO line should have been incremented")
+ self.assertEqual(sale_order_line2.price_unit, 10, "The unit price of SO line should be the same")
+ self.assertEqual(sale_order_line2.product_uom_qty, 0, "The ordered quantity of new SO line should remains zero")
+ self.assertEqual(sale_order_line2.qty_delivered, expense1.quantity + expense2.quantity, "The delivered quantity of SO line should have been incremented")
def test_no_expense(self):
""" Test invoicing expenses with no policy. Check nothing happen. """
@@ -234,7 +234,7 @@ class TestReInvoice(TestExpenseCommon, TestCommonSaleNoChart):
self.assertFalse(expense1.sale_order_id, "None reinvoicable expense can not be linked to SO")
self.assertFalse(self.sale_order.analytic_account_id, "Posting expense with an non expense product should not trigger analytic Account creation from SO, since non reinvoicable expense can not be linked to SO")
- self.assertEquals(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) on expense report posting")
- self.assertEquals(sale_order_line.price_unit, self.product_no_expense.list_price, "The unit price of SO line should be the same")
- self.assertEquals(sale_order_line.product_uom_qty, 2, "The ordered quantity of SO line should be two")
- self.assertEquals(sale_order_line.qty_delivered, 0, "The delivered quantity of SO line should have been incremented")
+ self.assertEqual(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) on expense report posting")
+ self.assertEqual(sale_order_line.price_unit, self.product_no_expense.list_price, "The unit price of SO line should be the same")
+ self.assertEqual(sale_order_line.product_uom_qty, 2, "The ordered quantity of SO line should be two")
+ self.assertEqual(sale_order_line.qty_delivered, 0, "The delivered quantity of SO line should have been incremented")
diff --git a/addons/sale_mrp/tests/test_sale_mrp_flow.py b/addons/sale_mrp/tests/test_sale_mrp_flow.py
index 274ed6b90a33..bcad55c50ea4 100644
--- a/addons/sale_mrp/tests/test_sale_mrp_flow.py
+++ b/addons/sale_mrp/tests/test_sale_mrp_flow.py
@@ -201,7 +201,7 @@ class TestSaleMrpFlow(common.SavepointCase):
"""
moves_to_process = moves.filtered(lambda m: m.product_id in quantities_to_process.keys())
for move in moves_to_process:
- self.assertEquals(move.product_uom_qty, quantities_to_process[move.product_id])
+ self.assertEqual(move.product_uom_qty, quantities_to_process[move.product_id])
def _create_move_quantities(self, qty_to_process, components, warehouse):
""" Helper to creates moves in order to update the quantities of components
@@ -703,24 +703,24 @@ class TestSaleMrpFlow(common.SavepointCase):
so.action_confirm()
# Check picking creation
- self.assertEquals(len(so.picking_ids), 1)
+ self.assertEqual(len(so.picking_ids), 1)
picking_original = so.picking_ids[0]
move_lines = picking_original.move_lines
# Check if the correct amount of stock.moves are created
- self.assertEquals(len(move_lines), 3)
+ self.assertEqual(len(move_lines), 3)
# Check if BoM is created and is for a 'Kit'
bom_from_k1 = self.env['mrp.bom']._bom_find(product=self.kit_1)
- self.assertEquals(self.bom_kit_1.id, bom_from_k1.id)
- self.assertEquals(bom_from_k1.type, 'phantom')
+ self.assertEqual(self.bom_kit_1.id, bom_from_k1.id)
+ self.assertEqual(bom_from_k1.type, 'phantom')
# Check there's only 1 order line on the SO and it's for x10 'kit_1'
order_lines = so.order_line
- self.assertEquals(len(order_lines), 1)
+ self.assertEqual(len(order_lines), 1)
order_line = order_lines[0]
- self.assertEquals(order_line.product_id.id, self.kit_1.id)
- self.assertEquals(order_line.product_uom_qty, 10.0)
+ self.assertEqual(order_line.product_id.id, self.kit_1.id)
+ self.assertEqual(order_line.product_uom_qty, 10.0)
# Check if correct qty is ordered for each component of the kit
expected_quantities = {
@@ -736,10 +736,10 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Check that the backorder was created, no kit should be delivered at this point
- self.assertEquals(len(so.picking_ids), 2)
+ self.assertEqual(len(so.picking_ids), 2)
backorder_1 = so.picking_ids - picking_original
- self.assertEquals(backorder_1.backorder_id.id, picking_original.id)
- self.assertEquals(order_line.qty_delivered, 0)
+ self.assertEqual(backorder_1.backorder_id.id, picking_original.id)
+ self.assertEqual(order_line.qty_delivered, 0)
# Process only x6 each componenent in the picking
# Then create a backorder for the missing components
@@ -748,13 +748,13 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Check that a backorder is created
- self.assertEquals(len(so.picking_ids), 3)
+ self.assertEqual(len(so.picking_ids), 3)
backorder_2 = so.picking_ids - picking_original - backorder_1
- self.assertEquals(backorder_2.backorder_id.id, backorder_1.id)
+ self.assertEqual(backorder_2.backorder_id.id, backorder_1.id)
# With x6 unit of each components, we can only make 2 kits.
# So only 2 kits should be delivered
- self.assertEquals(order_line.qty_delivered, 2)
+ self.assertEqual(order_line.qty_delivered, 2)
# Process x3 more unit of each components :
# - Now only 3 kits should be delivered
@@ -764,10 +764,10 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard = self.env['stock.backorder.confirmation'].create({'pick_ids': [(4, backorder_2.id)]})
backorder_wizard.process()
- self.assertEquals(len(so.picking_ids), 4)
+ self.assertEqual(len(so.picking_ids), 4)
backorder_3 = so.picking_ids - picking_original - backorder_2 - backorder_1
- self.assertEquals(backorder_3.backorder_id.id, backorder_2.id)
- self.assertEquals(order_line.qty_delivered, 3)
+ self.assertEqual(backorder_3.backorder_id.id, backorder_2.id)
+ self.assertEqual(order_line.qty_delivered, 3)
# Adding missing components
qty_to_process = {
@@ -782,7 +782,7 @@ class TestSaleMrpFlow(common.SavepointCase):
order_line._compute_qty_delivered()
# All kits should be delivered
- self.assertEquals(order_line.qty_delivered, 10)
+ self.assertEqual(order_line.qty_delivered, 10)
def test_04_sale_mrp_kit_qty_delivered(self):
""" Test that the quantities delivered are correct when
@@ -827,7 +827,7 @@ class TestSaleMrpFlow(common.SavepointCase):
# Check picking creation, its move lines should concern
# only components. Also checks that the quantities are corresponding
# to the SO
- self.assertEquals(len(so.picking_ids), 1)
+ self.assertEqual(len(so.picking_ids), 1)
order_line = so.order_line[0]
picking_original = so.picking_ids[0]
move_lines = picking_original.move_lines
@@ -844,7 +844,7 @@ class TestSaleMrpFlow(common.SavepointCase):
self.component_g: 28.0
}
- self.assertEquals(len(move_lines), 7)
+ self.assertEqual(len(move_lines), 7)
self.assertTrue(not any(kit in products for kit in kits))
self.assertTrue(all(component in products for component in components))
self._assert_quantities(move_lines, expected_quantities)
@@ -858,13 +858,13 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Check that a backorded is created
- self.assertEquals(len(so.picking_ids), 2)
+ self.assertEqual(len(so.picking_ids), 2)
backorder_1 = so.picking_ids - picking_original
- self.assertEquals(backorder_1.backorder_id.id, picking_original.id)
+ self.assertEqual(backorder_1.backorder_id.id, picking_original.id)
# Even if some components are delivered completely,
# no KitParent should be delivered
- self.assertEquals(order_line.qty_delivered, 0)
+ self.assertEqual(order_line.qty_delivered, 0)
# Process just enough components to make 1 kit_parent
qty_to_process = {
@@ -878,12 +878,12 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Only 1 kit_parent should be delivered at this point
- self.assertEquals(order_line.qty_delivered, 1)
+ self.assertEqual(order_line.qty_delivered, 1)
# Check that the second backorder is created
- self.assertEquals(len(so.picking_ids), 3)
+ self.assertEqual(len(so.picking_ids), 3)
backorder_2 = so.picking_ids - picking_original - backorder_1
- self.assertEquals(backorder_2.backorder_id.id, backorder_1.id)
+ self.assertEqual(backorder_2.backorder_id.id, backorder_1.id)
# Set the components quantities that backorder_2 should have
expected_quantities = {
@@ -898,7 +898,7 @@ class TestSaleMrpFlow(common.SavepointCase):
# Check that the computed quantities are matching the theorical ones.
# Since component_e was totally processed, this componenent shouldn't be
# present in backorder_2
- self.assertEquals(len(backorder_2.move_lines), 6)
+ self.assertEqual(len(backorder_2.move_lines), 6)
move_comp_e = backorder_2.move_lines.filtered(lambda m: m.product_id.id == self.component_e.id)
self.assertFalse(move_comp_e)
self._assert_quantities(backorder_2.move_lines, expected_quantities)
@@ -917,12 +917,12 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Check that x3 kit_parents are indeed delivered
- self.assertEquals(order_line.qty_delivered, 3)
+ self.assertEqual(order_line.qty_delivered, 3)
# Check that the third backorder is created
- self.assertEquals(len(so.picking_ids), 4)
+ self.assertEqual(len(so.picking_ids), 4)
backorder_3 = so.picking_ids - (picking_original + backorder_1 + backorder_2)
- self.assertEquals(backorder_3.backorder_id.id, backorder_2.id)
+ self.assertEqual(backorder_3.backorder_id.id, backorder_2.id)
# Check the components quantities that backorder_3 should have
expected_quantities = {
@@ -941,7 +941,7 @@ class TestSaleMrpFlow(common.SavepointCase):
# Validating the last backorder now it's complete.
# All kits should be delivered
backorder_3.button_validate()
- self.assertEquals(order_line.qty_delivered, 7.0)
+ self.assertEqual(order_line.qty_delivered, 7.0)
# Return all components processed by backorder_3
stock_return_picking_form = Form(self.env['stock.return.picking']
@@ -962,7 +962,7 @@ class TestSaleMrpFlow(common.SavepointCase):
wiz.process()
# Now quantity delivered should be 3 again
- self.assertEquals(order_line.qty_delivered, 3)
+ self.assertEqual(order_line.qty_delivered, 3)
stock_return_picking_form = Form(self.env['stock.return.picking']
.with_context(active_ids=return_pick.ids, active_id=return_pick.ids[0],
@@ -984,16 +984,16 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# As one of each component is missing, only 6 kit_parents should be delivered
- self.assertEquals(order_line.qty_delivered, 6)
+ self.assertEqual(order_line.qty_delivered, 6)
# Check that the 4th backorder is created.
- self.assertEquals(len(so.picking_ids), 7)
+ self.assertEqual(len(so.picking_ids), 7)
backorder_4 = so.picking_ids - (picking_original + backorder_1 + backorder_2 + backorder_3 + return_of_return_pick + return_pick)
- self.assertEquals(backorder_4.backorder_id.id, return_of_return_pick.id)
+ self.assertEqual(backorder_4.backorder_id.id, return_of_return_pick.id)
# Check the components quantities that backorder_4 should have
for move in backorder_4.move_lines:
- self.assertEquals(move.product_qty, 1)
+ self.assertEqual(move.product_qty, 1)
@mute_logger('odoo.tests.common.onchange')
def test_05_mrp_sale_kit_availability(self):
@@ -1051,8 +1051,8 @@ class TestSaleMrpFlow(common.SavepointCase):
# Check that not enough enough quantities are available in the warehouse set in the SO
# but there are enough quantities in Warehouse 1 for 1 kit_parent
- self.assertEquals(kit_parent_wh_order.virtual_available, 0)
- self.assertEquals(kit_parent_wh1.virtual_available, 1)
+ self.assertEqual(kit_parent_wh_order.virtual_available, 0)
+ self.assertEqual(kit_parent_wh1.virtual_available, 1)
# Check there arn't enough quantities available for the sale order
self.assertTrue(float_compare(order_line.virtual_available_at_date - order_line.product_uom_qty, 0, precision_rounding=line.product_uom.rounding) == -1)
@@ -1073,8 +1073,8 @@ class TestSaleMrpFlow(common.SavepointCase):
# But the quantity available in Warehouse 1 should stay 1
kit_parent_wh_order = self.kit_parent.with_context(warehouse=so.warehouse_id.id)
kit_parent_wh1 = self.kit_parent.with_context(warehouse=warehouse_1.id)
- self.assertEquals(kit_parent_wh_order.virtual_available, 3)
- self.assertEquals(kit_parent_wh1.virtual_available, 1)
+ self.assertEqual(kit_parent_wh_order.virtual_available, 3)
+ self.assertEqual(kit_parent_wh1.virtual_available, 1)
# Check there arn't enough quantities available for the sale order
self.assertTrue(float_compare(order_line.virtual_available_at_date - order_line.product_uom_qty, 0, precision_rounding=line.product_uom.rounding) == -1)
@@ -1093,7 +1093,7 @@ class TestSaleMrpFlow(common.SavepointCase):
# Enough quantities should be available, no warning message should be displayed
kit_parent_wh_order = self.kit_parent.with_context(warehouse=so.warehouse_id.id)
- self.assertEquals(kit_parent_wh_order.virtual_available, 7)
+ self.assertEqual(kit_parent_wh_order.virtual_available, 7)
def test_06_kit_qty_delivered_mixed_uom(self):
"""
@@ -1162,7 +1162,7 @@ class TestSaleMrpFlow(common.SavepointCase):
for ml in move_lines:
corr_bom_line = bom_kit_uom_1.bom_line_ids.filtered(lambda b: b.product_id.id == ml.product_id.id)
computed_qty = ml.product_uom._compute_quantity(ml.product_uom_qty, corr_bom_line.product_uom_id)
- self.assertEquals(computed_qty, order_line.product_uom_qty * corr_bom_line.product_qty)
+ self.assertEqual(computed_qty, order_line.product_uom_qty * corr_bom_line.product_qty)
# Processe enough componenents in the picking to make 2 kit_uom_1
# Then create a backorder for the missing components
@@ -1177,12 +1177,12 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_wizard.process()
# Check that a backorder is created
- self.assertEquals(len(so.picking_ids), 2)
+ self.assertEqual(len(so.picking_ids), 2)
backorder_1 = so.picking_ids - picking_original
- self.assertEquals(backorder_1.backorder_id.id, picking_original.id)
+ self.assertEqual(backorder_1.backorder_id.id, picking_original.id)
# Only 2 kits should be delivered
- self.assertEquals(order_line.qty_delivered, 2)
+ self.assertEqual(order_line.qty_delivered, 2)
# Adding missing components
qty_to_process = {
@@ -1196,7 +1196,7 @@ class TestSaleMrpFlow(common.SavepointCase):
backorder_1.button_validate()
order_line._compute_qty_delivered()
# All kits should be delivered
- self.assertEquals(order_line.qty_delivered, 10)
+ self.assertEqual(order_line.qty_delivered, 10)
@mute_logger('odoo.tests.common.onchange')
def test_07_kit_availability_mixed_uom(self):
@@ -1288,7 +1288,7 @@ class TestSaleMrpFlow(common.SavepointCase):
# but there are enough quantities in Warehouse 1 for 1 kit_parent
kit_uom_in_kit.with_context(warehouse=warehouse_1.id)._compute_quantities()
virtual_available_wh_order = kit_uom_in_kit.virtual_available
- self.assertEquals(virtual_available_wh_order, 1)
+ self.assertEqual(virtual_available_wh_order, 1)
# Check there arn't enough quantities available for the sale order
self.assertTrue(float_compare(order_line.virtual_available_at_date - order_line.product_uom_qty, 0, precision_rounding=line.product_uom.rounding) == -1)
@@ -1307,14 +1307,14 @@ class TestSaleMrpFlow(common.SavepointCase):
self.assertTrue(float_compare(order_line.virtual_available_at_date - order_line.product_uom_qty, 0, precision_rounding=line.product_uom.rounding) == -1)
kit_uom_in_kit.with_context(warehouse=warehouse_1.id)._compute_quantities()
virtual_available_wh_order = kit_uom_in_kit.virtual_available
- self.assertEquals(virtual_available_wh_order, 3)
+ self.assertEqual(virtual_available_wh_order, 3)
# We process enough quantities to have enough kit_uom_in_kit available for the sale order.
self._create_move_quantities(qty_to_process, components, warehouse_1)
# We check that enough quantities were processed to sell 5 kit_uom_in_kit
kit_uom_in_kit.with_context(warehouse=warehouse_1.id)._compute_quantities()
- self.assertEquals(kit_uom_in_kit.virtual_available, 5)
+ self.assertEqual(kit_uom_in_kit.virtual_available, 5)
def test_10_sale_mrp_kits_routes(self):
@@ -1388,16 +1388,16 @@ class TestSaleMrpFlow(common.SavepointCase):
# Now we check that the routes of the components were applied, in order to make sure the routes set
# on the kit itself are ignored
- self.assertEquals(len(order.picking_ids), 2)
- self.assertEquals(len(order.picking_ids[0].move_lines), 1)
- self.assertEquals(len(order.picking_ids[1].move_lines), 1)
+ self.assertEqual(len(order.picking_ids), 2)
+ self.assertEqual(len(order.picking_ids[0].move_lines), 1)
+ self.assertEqual(len(order.picking_ids[1].move_lines), 1)
moves = order.picking_ids.mapped('move_lines')
move_shelf1 = moves.filtered(lambda m: m.product_id == component_shelf1)
move_shelf2 = moves.filtered(lambda m: m.product_id == component_shelf2)
- self.assertEquals(move_shelf1.location_id.id, self.ref('stock.stock_location_components'))
- self.assertEquals(move_shelf1.location_dest_id.id, self.ref('stock.stock_location_customers'))
- self.assertEquals(move_shelf2.location_id.id, self.ref('stock.stock_location_14'))
- self.assertEquals(move_shelf2.location_dest_id.id, self.ref('stock.stock_location_customers'))
+ self.assertEqual(move_shelf1.location_id.id, self.ref('stock.stock_location_components'))
+ self.assertEqual(move_shelf1.location_dest_id.id, self.ref('stock.stock_location_customers'))
+ self.assertEqual(move_shelf2.location_id.id, self.ref('stock.stock_location_14'))
+ self.assertEqual(move_shelf2.location_dest_id.id, self.ref('stock.stock_location_customers'))
def test_11_sale_mrp_explode_kits_uom_quantities(self):
@@ -1447,14 +1447,14 @@ class TestSaleMrpFlow(common.SavepointCase):
# Now we check that the routes of the components were applied, in order to make sure the routes set
# on the kit itself are ignored
- self.assertEquals(len(order.picking_ids), 1)
- self.assertEquals(len(order.picking_ids[0].move_lines), 2)
+ self.assertEqual(len(order.picking_ids), 1)
+ self.assertEqual(len(order.picking_ids[0].move_lines), 2)
# Finally, we check the quantities for each component on the picking
move_component_unit = order.picking_ids[0].move_lines.filtered(lambda m: m.product_id == component_unit)
move_component_kg = order.picking_ids[0].move_lines - move_component_unit
- self.assertEquals(move_component_unit.product_uom_qty, 0.5)
- self.assertEquals(move_component_kg.product_uom_qty, 0.583)
+ self.assertEqual(move_component_unit.product_uom_qty, 0.5)
+ self.assertEqual(move_component_kg.product_uom_qty, 0.583)
def test_product_type_service_1(self):
route_manufacture = self.warehouse.manufacture_pull_id.route_id.id
diff --git a/addons/sale_stock/tests/test_sale_order_dates.py b/addons/sale_stock/tests/test_sale_order_dates.py
index 4cf0ae8823ae..c58e4d2debe2 100644
--- a/addons/sale_stock/tests/test_sale_order_dates.py
+++ b/addons/sale_stock/tests/test_sale_order_dates.py
@@ -55,7 +55,7 @@ class TestSaleExpectedDate(common.TransactionCase):
# current date + longest lead time from all of it's order lines
sale_order.write({'picking_policy': 'one'})
expected_date = fields.Datetime.now() + timedelta(days=15)
- self.assertAlmostEquals(expected_date, sale_order.expected_date,
+ self.assertAlmostEqual(expected_date, sale_order.expected_date,
msg="Wrong expected date on sale order!", delta=timedelta(seconds=1))
sale_order.action_confirm()
@@ -83,8 +83,8 @@ class TestSaleExpectedDate(common.TransactionCase):
for ml in picking.move_line_ids:
ml.qty_done = ml.product_uom_qty
picking.action_done()
- self.assertEquals(picking.state, 'done', "Picking not processed correctly!")
- self.assertEquals(fields.Date.today(), sale_order.effective_date, "Wrong effective date on sale order!")
+ self.assertEqual(picking.state, 'done', "Picking not processed correctly!")
+ self.assertEqual(fields.Date.today(), sale_order.effective_date, "Wrong effective date on sale order!")
def test_sale_order_commitment_date(self):
diff --git a/addons/sale_stock/tests/test_sale_stock.py b/addons/sale_stock/tests/test_sale_stock.py
index 2dd0250c33b7..686fc854330b 100644
--- a/addons/sale_stock/tests/test_sale_stock.py
+++ b/addons/sale_stock/tests/test_sale_stock.py
@@ -291,7 +291,7 @@ class TestSaleStock(TestSale):
# storable product, thus is unavailable. Hitting `button_validate` will first ask to
# process all the reserved quantities and, if the user chose to process, a second wizard
# will ask to create a backorder for the unavailable product.
- self.assertEquals(len(self.so.picking_ids), 1)
+ self.assertEqual(len(self.so.picking_ids), 1)
res_dict = self.so.picking_ids.sorted()[0].button_validate()
wizard = self.env[(res_dict.get('res_model'))].browse(res_dict.get('res_id'))
self.assertEqual(wizard._name, 'stock.immediate.transfer')
@@ -301,7 +301,7 @@ class TestSaleStock(TestSale):
wizard.process()
# Now, the original picking is done and there is a new one (the backorder).
- self.assertEquals(len(self.so.picking_ids), 2)
+ self.assertEqual(len(self.so.picking_ids), 2)
for picking in self.so.picking_ids:
move = picking.move_lines
if picking.backorder_id:
@@ -319,7 +319,7 @@ class TestSaleStock(TestSale):
]
})
# a single picking should be created for the new delivery
- self.assertEquals(len(self.so.picking_ids), 2)
+ self.assertEqual(len(self.so.picking_ids), 2)
backorder = self.so.picking_ids.filtered(lambda p: p.backorder_id)
self.assertEqual(len(backorder.move_lines), 2)
for backorder_move in backorder.move_lines:
@@ -347,11 +347,11 @@ class TestSaleStock(TestSale):
self.so.action_confirm()
# deliver them
- self.assertEquals(len(self.so.picking_ids), 1)
+ self.assertEqual(len(self.so.picking_ids), 1)
res_dict = self.so.picking_ids.sorted()[0].button_validate()
wizard = self.env[(res_dict.get('res_model'))].browse(res_dict.get('res_id'))
wizard.process()
- self.assertEquals(self.so.picking_ids.sorted()[0].state, "done")
+ self.assertEqual(self.so.picking_ids.sorted()[0].state, "done")
# update the two original sale order lines
self.so.write({
@@ -361,7 +361,7 @@ class TestSaleStock(TestSale):
]
})
# a single picking should be created for the new delivery
- self.assertEquals(len(self.so.picking_ids), 2)
+ self.assertEqual(len(self.so.picking_ids), 2)
def test_05_confirm_cancel_confirm(self):
""" Confirm a sale order, cancel it, set to quotation, change the
diff --git a/addons/sale_stock/tests/test_sale_stock_lead_time.py b/addons/sale_stock/tests/test_sale_stock_lead_time.py
index 58d912b02156..fbf6080059dc 100644
--- a/addons/sale_stock/tests/test_sale_stock_lead_time.py
+++ b/addons/sale_stock/tests/test_sale_stock_lead_time.py
@@ -178,9 +178,9 @@ class TestSaleStockLeadTime(TestStockCommon):
pick.write({'scheduled_date': pick_min_date + timedelta(days=5)})
# Now check scheduled_date of pack and out are changed or not based on propagate is true on rules?
- self.assertEquals(pack.scheduled_date, (pack_min_date + timedelta(days=5)),
+ self.assertEqual(pack.scheduled_date, (pack_min_date + timedelta(days=5)),
'Schedule date of pack should be changed based on delay.')
- self.assertEquals(out.scheduled_date, (out_min_date + timedelta(days=5)),
+ self.assertEqual(out.scheduled_date, (out_min_date + timedelta(days=5)),
'Schedule date of out should be changed based on delay.')
def test_03_no_propagate_date(self):
@@ -256,5 +256,5 @@ class TestSaleStockLeadTime(TestStockCommon):
pick.write({'scheduled_date': pick_min_date + timedelta(days=5)})
# Now check scheduled_date of pack and out are changed or not based on propagate is false on rules?
- self.assertEquals(pack.scheduled_date, pack_min_date, 'Schedule date of pack should not be changed.')
- self.assertEquals(out.scheduled_date, out_min_date, 'Schedule date of out should not be changed.')
+ self.assertEqual(pack.scheduled_date, pack_min_date, 'Schedule date of pack should not be changed.')
+ self.assertEqual(out.scheduled_date, out_min_date, 'Schedule date of out should not be changed.')
diff --git a/addons/sale_timesheet/tests/test_project_billing.py b/addons/sale_timesheet/tests/test_project_billing.py
index 7f0d533af8c3..a7c1514a8d5f 100644
--- a/addons/sale_timesheet/tests/test_project_billing.py
+++ b/addons/sale_timesheet/tests/test_project_billing.py
@@ -337,7 +337,7 @@ class TestProjectBilling(TestCommonSaleTimesheetNoChart):
'employee_id': self.employee_tde.id,
})
- self.assertEquals(timesheet4.so_line, self.so1_line_deliver_no_task, "The timesheet should be linked to SOL on the project, as no entry for TDE in project map and no SOL on task")
+ self.assertEqual(timesheet4.so_line, self.so1_line_deliver_no_task, "The timesheet should be linked to SOL on the project, as no entry for TDE in project map and no SOL on task")
def test_billing_task_rate(self):
""" Check task and subtask creation, and timesheeting in a project billed at 'task rate'. Then move the task into a 'employee rate' project then, 'non billable'. """
diff --git a/addons/sale_timesheet/tests/test_reinvoice.py b/addons/sale_timesheet/tests/test_reinvoice.py
index 5b3058ce5efa..2f3c66772076 100644
--- a/addons/sale_timesheet/tests/test_reinvoice.py
+++ b/addons/sale_timesheet/tests/test_reinvoice.py
@@ -73,8 +73,8 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
self.sale_order._compute_tax_id()
self.sale_order.action_confirm()
- self.assertEquals(sale_order_line1.qty_delivered_method, 'timesheet', "Delivered quantity of 'service' SO line should be computed by timesheet amount")
- self.assertEquals(sale_order_line2.qty_delivered_method, 'timesheet', "Delivered quantity of 'service' SO line should be computed by timesheet amount")
+ self.assertEqual(sale_order_line1.qty_delivered_method, 'timesheet', "Delivered quantity of 'service' SO line should be computed by timesheet amount")
+ self.assertEqual(sale_order_line2.qty_delivered_method, 'timesheet', "Delivered quantity of 'service' SO line should be computed by timesheet amount")
# let's log some timesheets (on the project created by sale_order_line1)
task_sol1 = sale_order_line1.task_id
@@ -104,21 +104,21 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
self.assertTrue(sale_order_line3, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line4, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
- self.assertEquals(sale_order_line2.qty_delivered, 0, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line2.qty_delivered, 0, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
self.assertFalse(sale_order_line3.task_id, "Adding a new expense SO line should not create a task (sol3)")
self.assertFalse(sale_order_line4.task_id, "Adding a new expense SO line should not create a task (sol4)")
- self.assertEquals(len(self.sale_order.project_ids), 1, "SO create only one project with its service line. Adding new expense SO line should not impact that")
+ self.assertEqual(len(self.sale_order.project_ids), 1, "SO create only one project with its service line. Adding new expense SO line should not impact that")
- self.assertEquals((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_ordered_cost.standard_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_deliver_cost.standard_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_ordered_cost.standard_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_deliver_cost.standard_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
- self.assertEquals(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
+ self.assertEqual(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
+ self.assertEqual(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line should be computed by analytic amount")
# create second invoice lines and validate it
move_form = Form(self.env['account.move'].with_context(default_type='in_invoice'))
@@ -140,11 +140,11 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
self.assertTrue(sale_order_line5, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line6, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 6, "There should be still 4 lines on the SO, no new created")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 4, "There should be still 2 expenses lines on the SO")
+ self.assertEqual(len(self.sale_order.order_line), 6, "There should be still 4 lines on the SO, no new created")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 4, "There should be still 2 expenses lines on the SO")
- self.assertEquals((sale_order_line5.price_unit, sale_order_line5.qty_delivered, sale_order_line5.product_uom_qty, sale_order_line5.qty_invoiced), (self.product_ordered_cost.standard_price, 2.0, 0, 0), 'Sale line 5 is wrong after confirming 2e vendor invoice')
- self.assertEquals((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line6.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_deliver_cost.standard_price, 2.0, 0, 0), 'Sale line 6 is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line5.price_unit, sale_order_line5.qty_delivered, sale_order_line5.product_uom_qty, sale_order_line5.qty_invoiced), (self.product_ordered_cost.standard_price, 2.0, 0, 0), 'Sale line 5 is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line6.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_deliver_cost.standard_price, 2.0, 0, 0), 'Sale line 6 is wrong after confirming 2e vendor invoice')
def test_sales_price(self):
""" Test invoicing vendor bill at sales price for products based on delivered and ordered quantities. Check no existing SO line is incremented, but when invoicing a
@@ -203,21 +203,21 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
self.assertTrue(sale_order_line3, "A new sale line should have been created with ordered product")
self.assertTrue(sale_order_line4, "A new sale line should have been created with delivered product")
- self.assertEquals(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line), 4, "There should be 4 lines on the SO (2 vendor bill lines created)")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 2, "There should be 4 lines on the SO (2 vendor bill lines created)")
- self.assertEquals(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
- self.assertEquals(sale_order_line2.qty_delivered, 0, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line1.qty_delivered, 1, "Exising SO line 1 should not be impacted by reinvoicing product at cost")
+ self.assertEqual(sale_order_line2.qty_delivered, 0, "Exising SO line 2 should not be impacted by reinvoicing product at cost")
self.assertFalse(sale_order_line3.task_id, "Adding a new expense SO line should not create a task (sol3)")
self.assertFalse(sale_order_line4.task_id, "Adding a new expense SO line should not create a task (sol4)")
- self.assertEquals(len(self.sale_order.project_ids), 1, "SO create only one project with its service line. Adding new expense SO line should not impact that")
+ self.assertEqual(len(self.sale_order.project_ids), 1, "SO create only one project with its service line. Adding new expense SO line should not impact that")
- self.assertEquals((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_deliver_sales_price.list_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_order_sales_price.list_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line3.price_unit, sale_order_line3.qty_delivered, sale_order_line3.product_uom_qty, sale_order_line3.qty_invoiced), (self.product_deliver_sales_price.list_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
+ self.assertEqual((sale_order_line4.price_unit, sale_order_line4.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line4.qty_invoiced), (self.product_order_sales_price.list_price, 3.0, 0, 0), 'Sale line is wrong after confirming vendor invoice')
- self.assertEquals(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 3 should be computed by analytic amount")
- self.assertEquals(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 4 should be computed by analytic amount")
+ self.assertEqual(sale_order_line3.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 3 should be computed by analytic amount")
+ self.assertEqual(sale_order_line4.qty_delivered_method, 'analytic', "Delivered quantity of 'expense' SO line 4 should be computed by analytic amount")
# create second invoice lines and validate it
move_form = Form(self.env['account.move'].with_context(default_type='in_invoice'))
@@ -239,10 +239,10 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
self.assertFalse(sale_order_line5, "No new sale line should have been created with delivered product !!")
self.assertTrue(sale_order_line6, "A new sale line should have been created with ordered product")
- self.assertEquals(len(self.sale_order.order_line), 5, "There should be 5 lines on the SO, 1 new created and 1 incremented")
- self.assertEquals(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 3, "There should be 3 expenses lines on the SO")
+ self.assertEqual(len(self.sale_order.order_line), 5, "There should be 5 lines on the SO, 1 new created and 1 incremented")
+ self.assertEqual(len(self.sale_order.order_line.filtered(lambda sol: sol.is_expense)), 3, "There should be 3 expenses lines on the SO")
- self.assertEquals((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_order_sales_price.list_price, 2.0, 0, 0), 'Sale line is wrong after confirming 2e vendor invoice')
+ self.assertEqual((sale_order_line6.price_unit, sale_order_line6.qty_delivered, sale_order_line4.product_uom_qty, sale_order_line6.qty_invoiced), (self.product_order_sales_price.list_price, 2.0, 0, 0), 'Sale line is wrong after confirming 2e vendor invoice')
def test_no_expense(self):
""" Test invoicing vendor bill with no policy. Check nothing happen. """
@@ -279,6 +279,6 @@ class TestReInvoice(TestCommonSaleTimesheetNoChart):
'employee_id': self.employee_user.id,
})
- self.assertEquals(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) when validating vendor bill")
- self.assertEquals(sale_order_line.qty_delivered, 1, "The delivered quantity of SO line should not have been incremented")
+ self.assertEqual(len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) when validating vendor bill")
+ self.assertEqual(sale_order_line.qty_delivered, 1, "The delivered quantity of SO line should not have been incremented")
self.assertTrue(invoice_a.mapped('line_ids.analytic_line_ids'), "Analytic lines should be generated")
diff --git a/addons/stock/tests/test_move2.py b/addons/stock/tests/test_move2.py
index e1380a8ec288..934841081ad1 100644
--- a/addons/stock/tests/test_move2.py
+++ b/addons/stock/tests/test_move2.py
@@ -902,8 +902,8 @@ class TestSinglePicking(TestStockCommon):
# No backorder should be created and the move corresponding to the missing product should be cancelled
backorder = self.env['stock.picking'].search([('backorder_id', '=', delivery_order.id)])
self.assertFalse(backorder)
- self.assertEquals(delivery_order.state, 'done')
- self.assertEquals(delivery_order.move_lines[1].state, 'cancel')
+ self.assertEqual(delivery_order.state, 'done')
+ self.assertEqual(delivery_order.move_lines[1].state, 'cancel')
def test_extra_move_1(self):
""" Check the good behavior of creating an extra move in a delivery order. This usecase
@@ -2161,16 +2161,16 @@ class TestRoutes(TestStockCommon):
# 3 pickings should be created.
picking_ids = self.env['stock.picking'].search([('group_id', '=', pg.id)])
- self.assertEquals(len(picking_ids), 3)
+ self.assertEqual(len(picking_ids), 3)
for picking in picking_ids:
# Only the picking from Stock to Pack should be MTS
if picking.location_id == warehouse.lot_stock_id:
- self.assertEquals(picking.move_lines.procure_method, 'make_to_stock')
+ self.assertEqual(picking.move_lines.procure_method, 'make_to_stock')
else:
- self.assertEquals(picking.move_lines.procure_method, 'make_to_order')
+ self.assertEqual(picking.move_lines.procure_method, 'make_to_order')
- self.assertEquals(len(picking.move_lines), 1)
- self.assertEquals(picking.move_lines.product_uom_qty, 5, 'The quantity of the move should be the same as on the SO')
+ self.assertEqual(len(picking.move_lines), 1)
+ self.assertEqual(picking.move_lines.product_uom_qty, 5, 'The quantity of the move should be the same as on the SO')
self.assertEqual(qty_available, 4, 'The 4 products should still be available')
def test_mtso_mts(self):
@@ -2213,11 +2213,11 @@ class TestRoutes(TestStockCommon):
# A picking should be created with its move having MTS as procure method.
picking_ids = self.env['stock.picking'].search([('group_id', '=', pg.id)])
- self.assertEquals(len(picking_ids), 1)
+ self.assertEqual(len(picking_ids), 1)
picking = picking_ids
- self.assertEquals(picking.move_lines.procure_method, 'make_to_stock')
- self.assertEquals(len(picking.move_lines), 1)
- self.assertEquals(picking.move_lines.product_uom_qty, 4)
+ self.assertEqual(picking.move_lines.procure_method, 'make_to_stock')
+ self.assertEqual(len(picking.move_lines), 1)
+ self.assertEqual(picking.move_lines.product_uom_qty, 4)
def test_mtso_multi_pg(self):
""" Run 3 procurements for 2 products at the same times when there are 4 in stock then
@@ -2291,23 +2291,23 @@ class TestRoutes(TestStockCommon):
# The 2 first procurements should have create only 1 picking since enough quantities
# are left in the delivery location
- self.assertEquals(len(pickings_pg1), 1)
- self.assertEquals(len(pickings_pg2), 1)
- self.assertEquals(pickings_pg1.move_lines.procure_method, 'make_to_stock')
- self.assertEquals(pickings_pg2.move_lines.procure_method, 'make_to_stock')
+ self.assertEqual(len(pickings_pg1), 1)
+ self.assertEqual(len(pickings_pg2), 1)
+ self.assertEqual(pickings_pg1.move_lines.procure_method, 'make_to_stock')
+ self.assertEqual(pickings_pg2.move_lines.procure_method, 'make_to_stock')
# The last one should have 3 pickings as there's nothing left in the delivery location
- self.assertEquals(len(pickings_pg3), 3)
+ self.assertEqual(len(pickings_pg3), 3)
for picking in pickings_pg3:
# Only the picking from Stock to Pack should be MTS
if picking.location_id == warehouse.lot_stock_id:
- self.assertEquals(picking.move_lines.procure_method, 'make_to_stock')
+ self.assertEqual(picking.move_lines.procure_method, 'make_to_stock')
else:
- self.assertEquals(picking.move_lines.procure_method, 'make_to_order')
+ self.assertEqual(picking.move_lines.procure_method, 'make_to_order')
# All the moves should be should have the same quantity as it is on each procurements
- self.assertEquals(len(picking.move_lines), 1)
- self.assertEquals(picking.move_lines.product_uom_qty, 2)
+ self.assertEqual(len(picking.move_lines), 1)
+ self.assertEqual(picking.move_lines.product_uom_qty, 2)
def test_delay_alert_1(self):
""" On a pick pack ship scenario, enable the delay alert flag on the pack rule. Edit the
diff --git a/addons/stock/tests/test_packing.py b/addons/stock/tests/test_packing.py
index 4f135c70cb73..cc7b9efb895d 100644
--- a/addons/stock/tests/test_packing.py
+++ b/addons/stock/tests/test_packing.py
@@ -74,8 +74,8 @@ class TestPacking(SavepointCase):
pick_picking.move_line_ids.filtered(lambda ml: ml.product_id == self.productB).qty_done = 2.0
first_pack = pick_picking.put_in_pack()
- self.assertEquals(len(pick_picking.package_level_ids), 1, 'Put some products in pack should create a package_level')
- self.assertEquals(pick_picking.package_level_ids[0].state, 'new', 'A new pack should be in state "new"')
+ self.assertEqual(len(pick_picking.package_level_ids), 1, 'Put some products in pack should create a package_level')
+ self.assertEqual(pick_picking.package_level_ids[0].state, 'new', 'A new pack should be in state "new"')
pick_picking.move_line_ids.filtered(lambda ml: ml.product_id == self.productA and ml.qty_done == 0.0).qty_done = 4.0
pick_picking.move_line_ids.filtered(lambda ml: ml.product_id == self.productB and ml.qty_done == 0.0).qty_done = 3.0
second_pack = pick_picking.put_in_pack()
@@ -106,42 +106,42 @@ class TestPacking(SavepointCase):
'location_dest_id': self.stock_location.id,
'company_id': picking.company_id.id,
})
- self.assertEquals(package_level.state, 'draft',
+ self.assertEqual(package_level.state, 'draft',
'The package_level should be in draft as it has no moves, move lines and is not confirmed')
picking.action_confirm()
self.assertEqual(len(picking.move_ids_without_package), 0)
self.assertEqual(len(picking.move_lines), 1,
'One move should be created when the package_level has been confirmed')
- self.assertEquals(len(package_level.move_ids), 1,
+ self.assertEqual(len(package_level.move_ids), 1,
'The move should be in the package level')
- self.assertEquals(package_level.state, 'confirmed',
+ self.assertEqual(package_level.state, 'confirmed',
'The package level must be state confirmed when picking is confirmed')
picking.action_assign()
self.assertEqual(len(picking.move_lines), 1,
'You still have only one move when the picking is assigned')
self.assertEqual(len(picking.move_lines.move_line_ids), 1,
'The move should have one move line which is the reservation')
- self.assertEquals(picking.move_line_ids.package_level_id.id, package_level.id,
+ self.assertEqual(picking.move_line_ids.package_level_id.id, package_level.id,
'The move line created should be linked to the package level')
- self.assertEquals(picking.move_line_ids.package_id.id, pack.id,
+ self.assertEqual(picking.move_line_ids.package_id.id, pack.id,
'The move line must have been reserved on the package of the package_level')
- self.assertEquals(picking.move_line_ids.result_package_id.id, pack.id,
+ self.assertEqual(picking.move_line_ids.result_package_id.id, pack.id,
'The move line must have the same package as result package')
- self.assertEquals(package_level.state, 'assigned', 'The package level must be in state assigned')
+ self.assertEqual(package_level.state, 'assigned', 'The package level must be in state assigned')
package_level.write({'is_done': True})
- self.assertEquals(len(package_level.move_line_ids), 1,
+ self.assertEqual(len(package_level.move_line_ids), 1,
'The package level should still keep one move line after have been set to "done"')
- self.assertEquals(package_level.move_line_ids[0].qty_done, 20.0,
+ self.assertEqual(package_level.move_line_ids[0].qty_done, 20.0,
'All quantity in package must be procesed in move line')
picking.button_validate()
self.assertEqual(len(picking.move_lines), 1,
'You still have only one move when the picking is assigned')
self.assertEqual(len(picking.move_lines.move_line_ids), 1,
'The move should have one move line which is the reservation')
- self.assertEquals(package_level.state, 'done', 'The package level must be in state done')
- self.assertEquals(pack.location_id.id, picking.location_dest_id.id,
+ self.assertEqual(package_level.state, 'done', 'The package level must be in state done')
+ self.assertEqual(pack.location_id.id, picking.location_dest_id.id,
'The quant package must be in the destination location')
- self.assertEquals(pack.quant_ids[0].location_id.id, picking.location_dest_id.id,
+ self.assertEqual(pack.quant_ids[0].location_id.id, picking.location_dest_id.id,
'The quant must be in the destination location')
def test_multi_pack_reservation(self):
diff --git a/addons/stock/tests/test_proc_rule.py b/addons/stock/tests/test_proc_rule.py
index 7789563ad217..8d33bfb85fa4 100644
--- a/addons/stock/tests/test_proc_rule.py
+++ b/addons/stock/tests/test_proc_rule.py
@@ -101,13 +101,13 @@ class TestProcRule(TransactionCase):
# change above the minimum delta
move_orig.date_expected += timedelta(days=6)
- self.assertAlmostEquals(move_dest.date_expected, move_dest_initial_date + timedelta(days=6), delta=timedelta(seconds=10), msg='date should be propagated as the minimum delta is below')
+ self.assertAlmostEqual(move_dest.date_expected, move_dest_initial_date + timedelta(days=6), delta=timedelta(seconds=10), msg='date should be propagated as the minimum delta is below')
# change below the minimum delta
move_dest_initial_date = move_dest.date_expected
move_orig.date_expected += timedelta(days=4)
- self.assertAlmostEquals(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated as the minimum delta is above')
+ self.assertAlmostEqual(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated as the minimum delta is above')
def test_rule_propagate_2(self):
move_dest = self.env['stock.move'].create({
@@ -133,11 +133,11 @@ class TestProcRule(TransactionCase):
# change below the minimum delta
move_orig.date_expected += timedelta(days=4)
- self.assertAlmostEquals(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated')
+ self.assertAlmostEqual(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated')
# change above the minimum delta
move_orig.date_expected += timedelta(days=2)
- self.assertAlmostEquals(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated')
+ self.assertAlmostEqual(move_dest.date_expected, move_dest_initial_date, delta=timedelta(seconds=10), msg='date should not be propagated')
def test_rule_propagate_3(self):
move_dest = self.env['stock.move'].create({
@@ -163,6 +163,6 @@ class TestProcRule(TransactionCase):
move_dest_initial_date = move_dest.date_expected
move_orig_initial_date = move_orig.date_expected
move_orig._action_done()
- self.assertAlmostEquals(move_orig.date_expected, move_orig_initial_date, delta=timedelta(seconds=10), msg='schedule date should not be impacted by action_done')
- self.assertAlmostEquals(move_orig.date, datetime.now(), delta=timedelta(seconds=10), msg='date should be now')
- self.assertAlmostEquals(move_dest.date_expected, move_dest_initial_date + timedelta(days=6), delta=timedelta(seconds=10), msg='date should be propagated')
+ self.assertAlmostEqual(move_orig.date_expected, move_orig_initial_date, delta=timedelta(seconds=10), msg='schedule date should not be impacted by action_done')
+ self.assertAlmostEqual(move_orig.date, datetime.now(), delta=timedelta(seconds=10), msg='date should be now')
+ self.assertAlmostEqual(move_dest.date_expected, move_dest_initial_date + timedelta(days=6), delta=timedelta(seconds=10), msg='date should be propagated')
diff --git a/addons/stock/tests/test_stock_flow.py b/addons/stock/tests/test_stock_flow.py
index 27990338ad3f..5f8de5e40d85 100644
--- a/addons/stock/tests/test_stock_flow.py
+++ b/addons/stock/tests/test_stock_flow.py
@@ -1542,7 +1542,7 @@ class TestStockFlow(TestStockCommon):
'location_dest_id': self.customer_location})
# validate this delivery order, it should be in the waiting state
picking_out.action_assign()
- self.assertEquals(picking_out.state, "confirmed")
+ self.assertEqual(picking_out.state, "confirmed")
# receive one product in stock
inventory = self.env['stock.inventory'].create({
@@ -1558,9 +1558,9 @@ class TestStockFlow(TestStockCommon):
inventory.action_validate()
# recheck availability of the delivery order, it should be assigned
picking_out.action_assign()
- self.assertEquals(len(picking_out.move_lines), 1.0)
- self.assertEquals(picking_out.move_lines.product_qty, 2.0)
- self.assertEquals(picking_out.state, "assigned")
+ self.assertEqual(len(picking_out.move_lines), 1.0)
+ self.assertEqual(picking_out.move_lines.product_qty, 2.0)
+ self.assertEqual(picking_out.state, "assigned")
def test_71_picking_state_all_at_once_force_assign(self):
""" This test will check that the state of the picking is correctly computed according
@@ -1590,7 +1590,7 @@ class TestStockFlow(TestStockCommon):
# validate this delivery order, it should be in the waiting state
picking_out.action_assign()
- self.assertEquals(picking_out.state, "confirmed")
+ self.assertEqual(picking_out.state, "confirmed")
def test_72_picking_state_partial_reserve(self):
""" This test will check that the state of the picking is correctly computed according
@@ -1633,7 +1633,7 @@ class TestStockFlow(TestStockCommon):
# validate this delivery order, it should be in partially available
picking_out.action_assign()
- self.assertEquals(picking_out.state, "assigned")
+ self.assertEqual(picking_out.state, "assigned")
# receive one product in stock
inventory = self.env['stock.inventory'].create({
@@ -1650,7 +1650,7 @@ class TestStockFlow(TestStockCommon):
# recheck availability of the delivery order, it should be assigned
picking_out.action_assign()
- self.assertEquals(picking_out.state, "assigned")
+ self.assertEqual(picking_out.state, "assigned")
def test_73_picking_state_partial_force_assign(self):
""" This test will check that the state of the picking is correctly computed according
@@ -1679,7 +1679,7 @@ class TestStockFlow(TestStockCommon):
# validate this delivery order, it should be in the waiting state
picking_out.action_assign()
- self.assertEquals(picking_out.state, "confirmed")
+ self.assertEqual(picking_out.state, "confirmed")
def test_74_move_state_waiting_mto(self):
""" This test will check that when a move is unreserved, its state changes to 'waiting' if
@@ -1734,9 +1734,9 @@ class TestStockFlow(TestStockCommon):
move_with_ancestors._do_unreserve()
other_move._do_unreserve()
- self.assertEquals(move_mto_alone.state, "draft")
- self.assertEquals(move_with_ancestors.state, "waiting")
- self.assertEquals(other_move.state, "confirmed")
+ self.assertEqual(move_mto_alone.state, "draft")
+ self.assertEqual(move_with_ancestors.state, "waiting")
+ self.assertEqual(other_move.state, "confirmed")
def test_80_partial_picking_without_backorder(self):
""" This test will create a picking with an initial demand for a product
@@ -1769,19 +1769,19 @@ class TestStockFlow(TestStockCommon):
self.assertFalse(picking.backorder_id)
# Checking that the original move is still in the same picking
- self.assertEquals(move_a.picking_id.id, picking.id)
+ self.assertEqual(move_a.picking_id.id, picking.id)
move_lines = picking.move_lines
move_done = move_lines.browse(move_a.id)
move_canceled = move_lines - move_done
# Checking that the original move was set to done
- self.assertEquals(move_done.product_uom_qty, 4)
- self.assertEquals(move_done.state, 'done')
+ self.assertEqual(move_done.product_uom_qty, 4)
+ self.assertEqual(move_done.state, 'done')
# Checking that the new move created was canceled
- self.assertEquals(move_canceled.product_uom_qty, 6)
- self.assertEquals(move_canceled.state, 'cancel')
+ self.assertEqual(move_canceled.product_uom_qty, 6)
+ self.assertEqual(move_canceled.state, 'cancel')
# Checking that the canceled move is in the original picking
self.assertIn(move_canceled.id, picking.move_lines.mapped('id'))
@@ -1968,11 +1968,11 @@ class TestStockFlow(TestStockCommon):
f.scheduled_date = fields.Datetime.now()
picking = f.save()
- self.assertEquals(f.state, 'draft')
+ self.assertEqual(f.state, 'draft')
picking.action_confirm()
f = Form(picking, view='stock.view_picking_form')
f.scheduled_date = fields.Datetime.now()
picking = f.save()
- self.assertEquals(f.state, 'confirmed')
+ self.assertEqual(f.state, 'confirmed')
diff --git a/addons/stock/tests/test_stock_location_search.py b/addons/stock/tests/test_stock_location_search.py
index ac83eebdfdc0..a7e27f54f602 100644
--- a/addons/stock/tests/test_stock_location_search.py
+++ b/addons/stock/tests/test_stock_location_search.py
@@ -20,9 +20,9 @@ class TestStockLocationSearch(common.TransactionCase):
def test_10_location_search_by_barcode(self):
"""Search stock location by barcode"""
location_names = self.location.name_search(name=self.barcode)
- self.assertEquals(len(location_names), 1)
+ self.assertEqual(len(location_names), 1)
location_id_found = location_names[0][0]
- self.assertEquals(self.location_barcode_id, location_id_found)
+ self.assertEqual(self.location_barcode_id, location_id_found)
def test_20_location_search_by_name(self):
"""Search stock location by name"""
diff --git a/addons/stock_dropshipping/tests/test_dropship.py b/addons/stock_dropshipping/tests/test_dropship.py
index 1c24dbea88df..93c56163af20 100644
--- a/addons/stock_dropshipping/tests/test_dropship.py
+++ b/addons/stock_dropshipping/tests/test_dropship.py
@@ -109,8 +109,8 @@ class TestDropship(common.TransactionCase):
purchase = self.env['purchase.order'].search([('partner_id', '=', supplier_dropship.id)])
self.assertTrue(purchase, "an RFQ should have been created by the scheduler")
purchase.button_confirm()
- self.assertEquals(purchase.state, 'purchase', 'Purchase order should be in the approved state')
- self.assertEquals(len(purchase.ids), 1, 'There should be one picking')
+ self.assertEqual(purchase.state, 'purchase', 'Purchase order should be in the approved state')
+ self.assertEqual(len(purchase.ids), 1, 'There should be one picking')
# Send the 200 pieces
purchase.picking_ids.move_lines.quantity_done = purchase.picking_ids.move_lines.product_qty
@@ -120,4 +120,4 @@ class TestDropship(common.TransactionCase):
move_line = self.env['stock.move.line'].search([
('location_dest_id', '=', self.env.ref('stock.stock_location_customers').id),
('product_id', '=', drop_shop_product.id)])
- self.assertEquals(len(move_line.ids), 1, 'There should be exactly one move line')
+ self.assertEqual(len(move_line.ids), 1, 'There should be exactly one move line')
diff --git a/addons/survey/tests/test_certification_badge.py b/addons/survey/tests/test_certification_badge.py
index 60ca29d62e60..6cb3bbbafc89 100644
--- a/addons/survey/tests/test_certification_badge.py
+++ b/addons/survey/tests/test_certification_badge.py
@@ -101,7 +101,7 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
def test_badge_configuration(self):
# add a certification badge on a new survey
challenge = self.env['gamification.challenge'].search([('reward_id', '=', self.certification_badge.id)])
- self.assertEquals(len(challenge), 0, """A challenge should not exist or be linked to the certification badge
+ self.assertEqual(len(challenge), 0, """A challenge should not exist or be linked to the certification badge
if the certification badge have not been activated on a certification survey""")
self.certification_survey.write({
@@ -110,13 +110,13 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
})
challenge = self.env['gamification.challenge'].search([('reward_id', '=', self.certification_badge.id)])
- self.assertEquals(len(challenge), 1,
+ self.assertEqual(len(challenge), 1,
"A challenge should be created if the certification badge is activated on a certification survey")
challenge_line = self.env['gamification.challenge.line'].search([('challenge_id', '=', challenge.id)])
- self.assertEquals(len(challenge_line), 1,
+ self.assertEqual(len(challenge_line), 1,
"A challenge_line should be created if the certification badge is activated on a certification survey")
goal = challenge_line.definition_id
- self.assertEquals(len(goal), 1,
+ self.assertEqual(len(goal), 1,
"A goal should be created if the certification badge is activated on a certification survey")
# don't give badge anymore
@@ -127,13 +127,13 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
'The certification badge should be inactive if give_badge is false.')
challenge = self.env['gamification.challenge'].search([('id', '=', challenge.id)])
- self.assertEquals(len(challenge), 0,
+ self.assertEqual(len(challenge), 0,
"The challenge should be deleted if the certification badge is unset from the certification survey")
challenge_line = self.env['gamification.challenge.line'].search([('id', '=', challenge_line.id)])
- self.assertEquals(len(challenge_line), 0,
+ self.assertEqual(len(challenge_line), 0,
"The challenge_line should be deleted if the certification badge is unset from the certification survey")
goal = self.env['gamification.goal'].search([('id', '=', goal.id)])
- self.assertEquals(len(goal), 0,
+ self.assertEqual(len(goal), 0,
"The goal should be deleted if the certification badge is unset from the certification survey")
# re active the badge in the survey
@@ -142,13 +142,13 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
'The certification badge should be active if give_badge is true.')
challenge = self.env['gamification.challenge'].search([('reward_id', '=', self.certification_badge.id)])
- self.assertEquals(len(challenge), 1,
+ self.assertEqual(len(challenge), 1,
"A challenge should be created if the certification badge is activated on a certification survey")
challenge_line = self.env['gamification.challenge.line'].search([('challenge_id', '=', challenge.id)])
- self.assertEquals(len(challenge_line), 1,
+ self.assertEqual(len(challenge_line), 1,
"A challenge_line should be created if the certification badge is activated on a certification survey")
goal = challenge_line.definition_id
- self.assertEquals(len(goal), 1,
+ self.assertEqual(len(goal), 1,
"A goal should be created if the certification badge is activated on a certification survey")
def test_certification_badge_access(self):
@@ -183,11 +183,11 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
self.assertEqual(len(certification_surveys), 3, 'There should be 3 certification survey created')
challenges = self.env['gamification.challenge'].search([('reward_id', 'in', certification_surveys.mapped('certification_badge_id').ids)])
- self.assertEquals(len(challenges), 3, "3 challenges should be created")
+ self.assertEqual(len(challenges), 3, "3 challenges should be created")
challenge_lines = self.env['gamification.challenge.line'].search([('challenge_id', 'in', challenges.ids)])
- self.assertEquals(len(challenge_lines), 3, "3 challenge_lines should be created")
+ self.assertEqual(len(challenge_lines), 3, "3 challenge_lines should be created")
goals = challenge_lines.mapped('definition_id')
- self.assertEquals(len(goals), 3, "3 goals should be created")
+ self.assertEqual(len(goals), 3, "3 goals should be created")
# Test write multi
certification_surveys.write({'certification_give_badge': False})
@@ -196,11 +196,11 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
'Every badge should be inactive if the 3 survey does not give badge anymore')
challenges = self.env['gamification.challenge'].search([('id', 'in', challenges.ids)])
- self.assertEquals(len(challenges), 0, "The 3 challenges should be deleted")
+ self.assertEqual(len(challenges), 0, "The 3 challenges should be deleted")
challenge_lines = self.env['gamification.challenge.line'].search([('id', 'in', challenge_lines.ids)])
- self.assertEquals(len(challenge_lines), 0, "The 3 challenge_lines should be deleted")
+ self.assertEqual(len(challenge_lines), 0, "The 3 challenge_lines should be deleted")
goals = self.env['gamification.goal'].search([('id', 'in', goals.ids)])
- self.assertEquals(len(goals), 0, "The 3 goals should be deleted")
+ self.assertEqual(len(goals), 0, "The 3 goals should be deleted")
certification_surveys.write({'certification_give_badge': True})
for survey in certification_surveys:
@@ -208,8 +208,8 @@ class TestCertificationBadge(common.SurveyCase, HttpCase):
'Every badge should be reactivated if the 3 survey give badges again')
challenges = self.env['gamification.challenge'].search([('reward_id', 'in', certification_surveys.mapped('certification_badge_id').ids)])
- self.assertEquals(len(challenges), 3, "3 challenges should be created")
+ self.assertEqual(len(challenges), 3, "3 challenges should be created")
challenge_lines = self.env['gamification.challenge.line'].search([('challenge_id', 'in', challenges.ids)])
- self.assertEquals(len(challenge_lines), 3, "3 challenge_lines should be created")
+ self.assertEqual(len(challenge_lines), 3, "3 challenge_lines should be created")
goals = challenge_lines.mapped('definition_id')
- self.assertEquals(len(goals), 3, "3 goals should be created")
+ self.assertEqual(len(goals), 3, "3 goals should be created")
diff --git a/addons/test_mail/tests/test_message_management.py b/addons/test_mail/tests/test_message_management.py
index bfdf1ccf5b0a..2a45477b9bf7 100644
--- a/addons/test_mail/tests/test_message_management.py
+++ b/addons/test_mail/tests/test_message_management.py
@@ -55,12 +55,12 @@ class TestMailResend(common.BaseFunctionalTest, common.MockEmails):
('res_partner_id', '=', partner.id),
('mail_message_id', '=', message.id)]
)
- self.assertEquals(notif.notification_status, state)
+ self.assertEqual(notif.notification_status, state)
return notif
def assertBusMessage(self, partners):
partner_ids = [elem[0][2] for elem in self.bus_update_failure]
- self.assertEquals(partner_ids, [partner.id for partner in partners])
+ self.assertEqual(partner_ids, [partner.id for partner in partners])
self.bus_update_failure.clear()
@classmethod
diff --git a/addons/test_mail_full/tests/test_sms_composer.py b/addons/test_mail_full/tests/test_sms_composer.py
index 04ff799408f0..060863e4f021 100644
--- a/addons/test_mail_full/tests/test_sms_composer.py
+++ b/addons/test_mail_full/tests/test_sms_composer.py
@@ -463,8 +463,8 @@ class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.M
})
# Call manually the onchange
composer._onchange_template_id()
- self.assertEquals(composer.composition_mode, "comment")
- self.assertEquals(composer.body, "Hello %s ceci est en français." % test_record_2.display_name)
+ self.assertEqual(composer.composition_mode, "comment")
+ self.assertEqual(composer.body, "Hello %s ceci est en français." % test_record_2.display_name)
with self.mockSMSGateway():
messages = composer._action_send_sms()
@@ -487,9 +487,9 @@ class TestSMSComposerMass(test_mail_full_common.BaseFunctionalTest, sms_common.M
})
# Call manually the onchange
composer._onchange_template_id()
- self.assertEquals(composer.composition_mode, "mass")
+ self.assertEqual(composer.composition_mode, "mass")
# In english because by default but when sinding depending of record
- self.assertEquals(composer.body, "Dear ${object.display_name} this is an SMS.")
+ self.assertEqual(composer.body, "Dear ${object.display_name} this is an SMS.")
with self.mockSMSGateway():
composer.action_send_sms()
diff --git a/addons/test_website/tests/test_controller_args.py b/addons/test_website/tests/test_controller_args.py
index 4204cb1e5b44..fc21c22a2d65 100644
--- a/addons/test_website/tests/test_controller_args.py
+++ b/addons/test_website/tests/test_controller_args.py
@@ -7,25 +7,25 @@ class TestWebsiteControllerArgs(odoo.tests.HttpCase):
def test_crawl_args(self):
req = self.url_open('/ignore_args/converter/valueA/?b=valueB&c=valueC')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': 'valueA', 'b': 'valueB', 'kw': {'c': 'valueC'}})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': 'valueA', 'b': 'valueB', 'kw': {'c': 'valueC'}})
req = self.url_open('/ignore_args/converter/valueA/nokw?b=valueB&c=valueC')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': 'valueA', 'b': 'valueB'})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': 'valueA', 'b': 'valueB'})
req = self.url_open('/ignore_args/converteronly/valueA/?b=valueB&c=valueC')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': 'valueA', 'kw': None})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': 'valueA', 'kw': None})
req = self.url_open('/ignore_args/none?a=valueA&b=valueB')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': None, 'kw': None})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': None, 'kw': None})
req = self.url_open('/ignore_args/a?a=valueA&b=valueB')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': 'valueA', 'kw': None})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': 'valueA', 'kw': None})
req = self.url_open('/ignore_args/kw?a=valueA&b=valueB')
- self.assertEquals(req.status_code, 200)
- self.assertEquals(req.json(), {'a': 'valueA', 'kw': {'b': 'valueB'}})
+ self.assertEqual(req.status_code, 200)
+ self.assertEqual(req.json(), {'a': 'valueA', 'kw': {'b': 'valueB'}})
diff --git a/addons/test_website/tests/test_views_during_module_operation.py b/addons/test_website/tests/test_views_during_module_operation.py
index 58cf943daf42..530284e2645e 100644
--- a/addons/test_website/tests/test_views_during_module_operation.py
+++ b/addons/test_website/tests/test_views_during_module_operation.py
@@ -58,7 +58,7 @@ class TestViewsDuringModuleOperation(TransactionCase):
update_module_child_view.with_context(website_id=1).write({'name': 'Child View (W1)'})
# Ensure views are correctly setup
- self.assertEquals(View.search_count([('type', '=', 'qweb'), ('key', '=', update_module_child_view.key)]), 2)
+ self.assertEqual(View.search_count([('type', '=', 'qweb'), ('key', '=', update_module_child_view.key)]), 2)
self.assertTrue(self.env.ref(update_module_view_to_be_t_called.key))
self.assertTrue(self.env.ref(update_module_base_view.key))
@@ -69,4 +69,4 @@ class TestViewsDuringModuleOperation(TransactionCase):
# Ensure generic views got removed
self.assertFalse(self.env.ref('test_website.update_module_view_to_be_t_called', raise_if_not_found=False))
# Ensure specific COW views got removed
- self.assertEquals(View.search_count([('type', '=', 'qweb'), ('key', '=', 'test_website.update_module_child_view')]), 0)
+ self.assertEqual(View.search_count([('type', '=', 'qweb'), ('key', '=', 'test_website.update_module_child_view')]), 0)
diff --git a/addons/uom/tests/test_uom.py b/addons/uom/tests/test_uom.py
index 26cbb5ef66ac..1b7dd2b1e1a9 100644
--- a/addons/uom/tests/test_uom.py
+++ b/addons/uom/tests/test_uom.py
@@ -18,10 +18,10 @@ class TestUom(TransactionCase):
def test_10_conversion(self):
qty = self.uom_gram._compute_quantity(1020000, self.uom_ton)
- self.assertEquals(qty, 1.02, "Converted quantity does not correspond.")
+ self.assertEqual(qty, 1.02, "Converted quantity does not correspond.")
price = self.uom_gram._compute_price(2, self.uom_ton)
- self.assertEquals(price, 2000000.0, "Converted price does not correspond.")
+ self.assertEqual(price, 2000000.0, "Converted price does not correspond.")
# If the conversion factor for Dozens (1/12) is not stored with sufficient precision,
# the conversion of 1 Dozen into Units will give e.g. 12.00000000000047 Units
@@ -29,13 +29,13 @@ class TestUom(TransactionCase):
# This is a partial regression test for rev. 311c77bb, which is further improved
# by rev. fa2f7b86.
qty = self.uom_dozen._compute_quantity(1, self.uom_unit)
- self.assertEquals(qty, 12.0, "Converted quantity does not correspond.")
+ self.assertEqual(qty, 12.0, "Converted quantity does not correspond.")
# Regression test for side-effect of commit 311c77bb - converting 1234 Grams
# into Kilograms should work even if grams are rounded to 1.
self.uom_gram.write({'rounding': 1})
qty = self.uom_gram._compute_quantity(1234, self.uom_kgm)
- self.assertEquals(qty, 1.234, "Converted quantity does not correspond.")
+ self.assertEqual(qty, 1.234, "Converted quantity does not correspond.")
def test_20_rounding(self):
product_uom = self.env['uom.uom'].create({
@@ -47,7 +47,7 @@ class TestUom(TransactionCase):
})
qty = self.uom_unit._compute_quantity(2, product_uom)
- self.assertEquals(qty, 1, "Converted quantity should be rounded up.")
+ self.assertEqual(qty, 1, "Converted quantity should be rounded up.")
def test_30_reference_uniqueness(self):
""" Check the uniqueness of the reference UoM in a category """
diff --git a/addons/web/controllers/main.py b/addons/web/controllers/main.py
index 3aa2c0e64d99..d893271ac6c9 100644
--- a/addons/web/controllers/main.py
+++ b/addons/web/controllers/main.py
@@ -1292,7 +1292,7 @@ class Binary(http.Controller):
try:
attachment = Model.create({
'name': filename,
- 'datas': base64.encodestring(ufile.read()),
+ 'datas': base64.encodebytes(ufile.read()),
'res_model': model,
'res_id': int(id)
})
diff --git a/addons/web_editor/models/ir_qweb.py b/addons/web_editor/models/ir_qweb.py
index 9077fab0389b..50e3a1a43e72 100644
--- a/addons/web_editor/models/ir_qweb.py
+++ b/addons/web_editor/models/ir_qweb.py
@@ -250,7 +250,7 @@ class DateTime(models.AbstractModel):
dt = user_tz.localize(dt).astimezone(utc)
except Exception:
- logger.warn(
+ logger.warning(
"Failed to convert the value for a field of the model"
" %s back from the user's timezone (%s) to UTC",
model, tz_name,
diff --git a/addons/website/models/ir_http.py b/addons/website/models/ir_http.py
index ecacdc62bac1..53f64fafda4e 100644
--- a/addons/website/models/ir_http.py
+++ b/addons/website/models/ir_http.py
@@ -285,9 +285,9 @@ class Http(models.AbstractModel):
# Needed to show reset template on translated pages (`_prepare_qcontext` will set it for main lang)
values['editable'] = request.uid and request.website.is_publisher()
elif code == 403:
- logger.warn("403 Forbidden:\n\n%s", values['traceback'])
+ logger.warning("403 Forbidden:\n\n%s", values['traceback'])
elif code == 400:
- logger.warn("400 Bad Request:\n\n%s", values['traceback'])
+ logger.warning("400 Bad Request:\n\n%s", values['traceback'])
try:
html = env['ir.ui.view'].render_template('website.%s' % view_id, values)
except Exception:
diff --git a/addons/website/models/website.py b/addons/website/models/website.py
index 0ddca6810e2a..3902f5dae8a4 100644
--- a/addons/website/models/website.py
+++ b/addons/website/models/website.py
@@ -667,14 +667,15 @@ class Website(models.Model):
return False
# dont't list routes without argument having no default value or converter
- spec = inspect.getargspec(endpoint.method.original_func)
-
- # remove self and arguments having a default value
- defaults_count = len(spec.defaults or [])
- args = spec.args[1:(-defaults_count or None)]
+ sign = inspect.signature(endpoint.method.original_func)
+ params = list(sign.parameters.values())[1:] # skip self
+ supported_kinds = (inspect.Parameter.POSITIONAL_ONLY,
+ inspect.Parameter.POSITIONAL_OR_KEYWORD)
+ has_no_default = lambda p: p.default is inspect.Parameter.empty
# check that all args have a converter
- return all((arg in rule._converters) for arg in args)
+ return all(p.name in rule._converters for p in params
+ if p.kind in supported_kinds and has_no_default(p))
def enumerate_pages(self, query_string=None, force=False):
""" Available pages in the website/CMS. This is mostly used for links
diff --git a/addons/website_form/controllers/main.py b/addons/website_form/controllers/main.py
index 81d7cf363faf..b2688c76c7e5 100644
--- a/addons/website_form/controllers/main.py
+++ b/addons/website_form/controllers/main.py
@@ -214,7 +214,7 @@ class WebsiteForm(http.Controller):
custom_field = file.field_name not in authorized_fields
attachment_value = {
'name': file.filename,
- 'datas': base64.encodestring(file.read()),
+ 'datas': base64.encodebytes(file.read()),
'res_model': model_name,
'res_id': record.id,
}
diff --git a/addons/website_mail_channel/tests/test_unsubscribe.py b/addons/website_mail_channel/tests/test_unsubscribe.py
index ec1a915f2326..28934d5f49d4 100644
--- a/addons/website_mail_channel/tests/test_unsubscribe.py
+++ b/addons/website_mail_channel/tests/test_unsubscribe.py
@@ -25,7 +25,7 @@ class TestConfirmUnsubscribe(common.HttpCase):
def test_not_subscribed_no_template(self):
""" Test warning works on db without template (code update w/o module update) """
self.env.ref('website_mail_channel.not_subscribed').unlink()
- self.assertEquals(
+ self.assertEqual(
self.env['ir.model.data'].search_count([
('module', '=', 'website_mail_channel'),
('name', '=', 'not_subscribed'),
diff --git a/addons/website_sale/tests/test_website_sale_pricelist.py b/addons/website_sale/tests/test_website_sale_pricelist.py
index 59af832fc74c..d6a372aae5ce 100644
--- a/addons/website_sale/tests/test_website_sale_pricelist.py
+++ b/addons/website_sale/tests/test_website_sale_pricelist.py
@@ -91,7 +91,7 @@ class TestWebsitePriceList(TransactionCase):
}
for country, result in country_list.items():
pls = self.get_pl(show, current_pl, country)
- self.assertEquals(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
+ self.assertEqual(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
% (country, len(pls), pls.mapped('name'), len(result), result))
def test_get_pricelist_available_not_show(self):
@@ -108,7 +108,7 @@ class TestWebsitePriceList(TransactionCase):
for country, result in country_list.items():
pls = self.get_pl(show, current_pl, country)
- self.assertEquals(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
+ self.assertEqual(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
% (country, len(pls), pls.mapped('name'), len(result), result))
def test_get_pricelist_available_promocode(self):
@@ -145,7 +145,7 @@ class TestWebsitePriceList(TransactionCase):
}
for country, result in country_list.items():
pls = self.get_pl(show, current_pl, country)
- self.assertEquals(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
+ self.assertEqual(len(set(pls.mapped('name')) & set(result)), len(pls), 'Test failed for %s (%s %s vs %s %s)'
% (country, len(pls), pls.mapped('name'), len(result), result))
diff --git a/addons/website_sale_comparison/tests/test_website_sale_comparison.py b/addons/website_sale_comparison/tests/test_website_sale_comparison.py
index 21e1db939d72..9f68b49c6bc9 100644
--- a/addons/website_sale_comparison/tests/test_website_sale_comparison.py
+++ b/addons/website_sale_comparison/tests/test_website_sale_comparison.py
@@ -39,9 +39,9 @@ class TestWebsiteSaleComparison(odoo.tests.TransactionCase):
product.with_context(website_id=1).write({'name': 'Trigger COW'})
# Verify initial state: the specific views exist
- self.assertEquals(Website1.viewref('website_sale.product').website_id.id, 1)
- self.assertEquals(Website1.viewref('website_sale_comparison.product_add_to_compare').website_id.id, 1)
- self.assertEquals(Website1.viewref(test_view_key).website_id.id, 1)
+ self.assertEqual(Website1.viewref('website_sale.product').website_id.id, 1)
+ self.assertEqual(Website1.viewref('website_sale_comparison.product_add_to_compare').website_id.id, 1)
+ self.assertEqual(Website1.viewref(test_view_key).website_id.id, 1)
# Remove the module (use `module_uninstall` because it is enough to test
# what we want here, no need/can't use `button_immediate_uninstall`
diff --git a/addons/website_theme_install/tests/test_views.py b/addons/website_theme_install/tests/test_views.py
index 42be90dfbd5b..a81fd1da4e8b 100644
--- a/addons/website_theme_install/tests/test_views.py
+++ b/addons/website_theme_install/tests/test_views.py
@@ -70,13 +70,13 @@ class Crawler(HttpCase):
# It should crash as it should not find a view on website 1 for '_theme_kea_sale.products', !!and certainly not a theme.ir.ui.view!!.
view = View.with_context(website_id=website_1.id)._view_obj('_theme_kea_sale.products')
view = View.with_context(website_id=website_2.id)._view_obj('_theme_kea_sale.products')
- self.assertEquals(len(view), 1, "It should find the ir.ui.view with key '_theme_kea_sale.products' on website 2..")
- self.assertEquals(view._name, 'ir.ui.view', "..and not a theme.ir.ui.view")
+ self.assertEqual(len(view), 1, "It should find the ir.ui.view with key '_theme_kea_sale.products' on website 2..")
+ self.assertEqual(view._name, 'ir.ui.view', "..and not a theme.ir.ui.view")
views = View.with_context(website_id=website_1.id).get_related_views('_website_sale.products')
- self.assertEquals(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_website_sale.child_view_w1'] should be returned")
+ self.assertEqual(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_website_sale.child_view_w1'] should be returned")
views = View.with_context(website_id=website_2.id).get_related_views('_website_sale.products')
- self.assertEquals(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_theme_kea_sale.products'] should be returned")
+ self.assertEqual(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_theme_kea_sale.products'] should be returned")
# Part 2 of the test, it test the same stuff but from a higher level (get_related_views ends up calling _view_obj)
called_theme_view = self.env['theme.ir.ui.view'].with_context(install_filename='/testviews').create({
@@ -115,9 +115,9 @@ class Crawler(HttpCase):
# Next line should not crash (was mixing apples and oranges - ir.ui.view and theme.ir.ui.view)
views = View.with_context(website_id=website_1.id).get_related_views('_website_sale.products')
- self.assertEquals(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_website_sale.child_view_w1'] should be returned (2)")
+ self.assertEqual(len(views), 2, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_website_sale.child_view_w1'] should be returned (2)")
views = View.with_context(website_id=website_2.id).get_related_views('_website_sale.products')
- self.assertEquals(len(views), 3, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_theme_kea_sale.products', '_theme_kea_sale.t_called_view'] should be returned")
+ self.assertEqual(len(views), 3, "It should not mix apples and oranges, only ir.ui.view ['_website_sale.products', '_theme_kea_sale.products', '_theme_kea_sale.t_called_view'] should be returned")
# ########################################################
# Test the controller (which is calling get_related_views)
diff --git a/odoo/addons/base/models/ir_actions_report.py b/odoo/addons/base/models/ir_actions_report.py
index a3d354cfabc0..b27c801ac048 100644
--- a/odoo/addons/base/models/ir_actions_report.py
+++ b/odoo/addons/base/models/ir_actions_report.py
@@ -179,7 +179,7 @@ class IrActionsReport(models.Model):
img = Image.open(stream)
img.convert("RGB").save(stream, format="pdf")
return stream
- return io.BytesIO(base64.decodestring(attachment.datas))
+ return io.BytesIO(base64.decodebytes(attachment.datas))
def retrieve_attachment(self, record):
'''Retrieve an attachment for a specific record.
@@ -211,7 +211,7 @@ class IrActionsReport(models.Model):
return None
attachment_vals = {
'name': attachment_name,
- 'datas': base64.encodestring(buffer.getvalue()),
+ 'datas': base64.encodebytes(buffer.getvalue()),
'res_model': self.model,
'res_id': record.id,
'type': 'binary',
diff --git a/odoo/addons/base/models/ir_model.py b/odoo/addons/base/models/ir_model.py
index 1ec2cd6de2a6..a330a7de5a71 100644
--- a/odoo/addons/base/models/ir_model.py
+++ b/odoo/addons/base/models/ir_model.py
@@ -647,7 +647,7 @@ class IrModelFields(models.Model):
]))
else:
# uninstall mode
- _logger.warn("The following fields were force-deleted to prevent a registry crash "
+ _logger.warning("The following fields were force-deleted to prevent a registry crash "
+ ", ".join(str(f) for f in fields)
+ " the following view might be broken %s" % view.name)
finally:
diff --git a/odoo/addons/base/models/ir_ui_menu.py b/odoo/addons/base/models/ir_ui_menu.py
index 9cde7d2fb810..b63d201ecf30 100644
--- a/odoo/addons/base/models/ir_ui_menu.py
+++ b/odoo/addons/base/models/ir_ui_menu.py
@@ -67,7 +67,7 @@ class IrUiMenu(models.Model):
icon_image = False
if icon_path:
with tools.file_open(icon_path, 'rb') as icon_file:
- icon_image = base64.encodestring(icon_file.read())
+ icon_image = base64.encodebytes(icon_file.read())
return icon_image
@api.constrains('parent_id')
diff --git a/odoo/addons/base/models/ir_ui_view.py b/odoo/addons/base/models/ir_ui_view.py
index 27dca34fffa5..a89391d6d7cb 100644
--- a/odoo/addons/base/models/ir_ui_view.py
+++ b/odoo/addons/base/models/ir_ui_view.py
@@ -351,7 +351,7 @@ actual arch.
message = "View inheritance may not use attribute %r as a selector." % match.group(1)
self.raise_view_error(message, self.id)
if WRONGCLASS.search(node.get('expr', '')):
- _logger.warn(
+ _logger.warning(
"Error-prone use of @class in view %s (%s): use the "
"hasclass(*classes) function to filter elements by "
"their classes", self.name, self.xml_id
diff --git a/odoo/addons/base/models/res_users.py b/odoo/addons/base/models/res_users.py
index 373b3c3bbdcb..f3bdb3094e3b 100644
--- a/odoo/addons/base/models/res_users.py
+++ b/odoo/addons/base/models/res_users.py
@@ -823,7 +823,7 @@ class Users(models.Model):
source = request.httprequest.remote_addr
(failures, previous) = failures_map[source]
if self._on_login_cooldown(failures, previous):
- _logger.warn(
+ _logger.warning(
"Login attempt ignored for %s on %s: "
"%d failures since last success, last failure at %s. "
"You can configure the number of login failures before a "
@@ -832,7 +832,7 @@ class Users(models.Model):
"\"base.login_cooldown_after\" to 0.",
source, self.env.cr.dbname, failures, previous)
if ipaddress.ip_address(source).is_private:
- _logger.warn(
+ _logger.warning(
"The rate-limited IP address %s is classified as private "
"and *might* be a proxy. If your Odoo is behind a proxy, "
"it may be mis-configured. Check that you are running "
@@ -879,7 +879,7 @@ class Users(models.Model):
def _register_hook(self):
if hasattr(self, 'check_credentials'):
- _logger.warn("The check_credentials method of res.users has been renamed _check_credentials. One of your installed modules defines one, but it will not be called anymore.")
+ _logger.warning("The check_credentials method of res.users has been renamed _check_credentials. One of your installed modules defines one, but it will not be called anymore.")
#
# Implied groups
#
diff --git a/odoo/addons/base/tests/test_acl.py b/odoo/addons/base/tests/test_acl.py
index 4c8954d7f62c..efecd0c201f3 100644
--- a/odoo/addons/base/tests/test_acl.py
+++ b/odoo/addons/base/tests/test_acl.py
@@ -35,7 +35,7 @@ class TestACL(TransactionCase):
has_group_system = self.demo_user.has_group(GROUP_SYSTEM)
self.assertFalse(has_group_system, "`demo` user should not belong to the restricted group before the test")
self.assertIn('decimal_places', original_fields, "'decimal_places' field must be properly visible before the test")
- self.assertNotEquals(view_arch.xpath("//field[@name='decimal_places']"), [],
+ self.assertNotEqual(view_arch.xpath("//field[@name='decimal_places']"), [],
"Field 'decimal_places' must be found in view definition before the test")
# restrict access to the field and check it's gone
@@ -45,7 +45,7 @@ class TestACL(TransactionCase):
form_view = currency.fields_view_get(False, 'form')
view_arch = etree.fromstring(form_view.get('arch'))
self.assertNotIn('decimal_places', fields, "'decimal_places' field should be gone")
- self.assertEquals(view_arch.xpath("//field[@name='decimal_places']"), [],
+ self.assertEqual(view_arch.xpath("//field[@name='decimal_places']"), [],
"Field 'decimal_places' must not be found in view definition")
# Make demo user a member of the restricted group and check that the field is back
@@ -56,7 +56,7 @@ class TestACL(TransactionCase):
view_arch = etree.fromstring(form_view.get('arch'))
self.assertTrue(has_group_system, "`demo` user should now belong to the restricted group")
self.assertIn('decimal_places', fields, "'decimal_places' field must be properly visible again")
- self.assertNotEquals(view_arch.xpath("//field[@name='decimal_places']"), [],
+ self.assertNotEqual(view_arch.xpath("//field[@name='decimal_places']"), [],
"Field 'decimal_places' must be found in view definition again")
@mute_logger('odoo.models')
@@ -67,8 +67,8 @@ class TestACL(TransactionCase):
# Verify the test environment first
has_group_system = self.demo_user.has_group(GROUP_SYSTEM)
self.assertFalse(has_group_system, "`demo` user should not belong to the restricted group")
- self.assert_(partner.read(['bank_ids']))
- self.assert_(partner.write({'bank_ids': []}))
+ self.assertTrue(partner.read(['bank_ids']))
+ self.assertTrue(partner.write({'bank_ids': []}))
# Now restrict access to the field and check it's forbidden
self._set_field_groups(partner, 'bank_ids', GROUP_SYSTEM)
@@ -82,8 +82,8 @@ class TestACL(TransactionCase):
self.erp_system_group.users += self.demo_user
has_group_system = self.demo_user.has_group(GROUP_SYSTEM)
self.assertTrue(has_group_system, "`demo` user should now belong to the restricted group")
- self.assert_(partner.read(['bank_ids']))
- self.assert_(partner.write({'bank_ids': []}))
+ self.assertTrue(partner.read(['bank_ids']))
+ self.assertTrue(partner.write({'bank_ids': []}))
@mute_logger('odoo.models')
def test_fields_browse_restriction(self):
diff --git a/odoo/addons/base/tests/test_base.py b/odoo/addons/base/tests/test_base.py
index 5051fec4dade..28fd7813722c 100644
--- a/odoo/addons/base/tests/test_base.py
+++ b/odoo/addons/base/tests/test_base.py
@@ -165,7 +165,7 @@ class TestBase(TransactionCase):
'street': 'Strongarm Avenue, 12',
'parent_id': ironshield.id,
})
- self.assertEquals(p1.type, 'contact', 'Default type must be "contact", not the copied parent type')
+ self.assertEqual(p1.type, 'contact', 'Default type must be "contact", not the copied parent type')
self.assertEqual(ironshield.street, p1.street, 'Address fields should be copied to company')
def test_40_res_partner_address_get(self):
@@ -318,30 +318,30 @@ class TestBase(TransactionCase):
p3 = res_partner.search([('email', '=', 'ugr@sunhelm.com')], limit=1)
for p in (p0, p1, p11, p2, p3):
- self.assertEquals(p.commercial_partner_id, sunhelm, 'Incorrect commercial entity resolution')
- self.assertEquals(p.vat, sunhelm.vat, 'Commercial fields must be automatically synced')
+ self.assertEqual(p.commercial_partner_id, sunhelm, 'Incorrect commercial entity resolution')
+ self.assertEqual(p.vat, sunhelm.vat, 'Commercial fields must be automatically synced')
sunhelmvat = 'BE0123456789'
sunhelm.write({'vat': sunhelmvat})
for p in (p0, p1, p11, p2, p3):
- self.assertEquals(p.vat, sunhelmvat, 'Commercial fields must be automatically and recursively synced')
+ self.assertEqual(p.vat, sunhelmvat, 'Commercial fields must be automatically and recursively synced')
p1vat = 'BE0987654321'
p1.write({'vat': p1vat})
for p in (sunhelm, p0, p11, p2, p3):
- self.assertEquals(p.vat, sunhelmvat, 'Sync to children should only work downstream and on commercial entities')
+ self.assertEqual(p.vat, sunhelmvat, 'Sync to children should only work downstream and on commercial entities')
# promote p1 to commercial entity
p1.write({'parent_id': sunhelm.id,
'is_company': True,
'name': 'Sunhelm Subsidiary'})
- self.assertEquals(p1.vat, p1vat, 'Setting is_company should stop auto-sync of commercial fields')
- self.assertEquals(p1.commercial_partner_id, p1, 'Incorrect commercial entity resolution after setting is_company')
+ self.assertEqual(p1.vat, p1vat, 'Setting is_company should stop auto-sync of commercial fields')
+ self.assertEqual(p1.commercial_partner_id, p1, 'Incorrect commercial entity resolution after setting is_company')
# writing on parent should not touch child commercial entities
sunhelmvat2 = 'BE0112233445'
sunhelm.write({'vat': sunhelmvat2})
- self.assertEquals(p1.vat, p1vat, 'Setting is_company should stop auto-sync of commercial fields')
- self.assertEquals(p0.vat, sunhelmvat2, 'Commercial fields must be automatically synced')
+ self.assertEqual(p1.vat, p1vat, 'Setting is_company should stop auto-sync of commercial fields')
+ self.assertEqual(p0.vat, sunhelmvat2, 'Commercial fields must be automatically synced')
def test_60_read_group(self):
title_sir = self.env['res.partner.title'].create({'name': 'Sir...'})
diff --git a/odoo/addons/base/tests/test_basecase.py b/odoo/addons/base/tests/test_basecase.py
index 8bd78f860fab..a4aa02559b85 100644
--- a/odoo/addons/base/tests/test_basecase.py
+++ b/odoo/addons/base/tests/test_basecase.py
@@ -67,6 +67,6 @@ class TestTransactionCase(common.TransactionCase):
xid = 'base.test_partner_yellow'
partner = self.env.ref(xid)
pid = self.ref(xid)
- self.assertEquals(pid, partner.id, "ref() should resolve xid to database ID")
+ self.assertEqual(pid, partner.id, "ref() should resolve xid to database ID")
partner2 = self.browse_ref(xid)
self.assertEqual(partner, partner2, "browse_ref() should resolve xid to browse records")
diff --git a/odoo/addons/base/tests/test_mail.py b/odoo/addons/base/tests/test_mail.py
index 11fac3a885d6..1f67c2365f9b 100644
--- a/odoo/addons/base/tests/test_mail.py
+++ b/odoo/addons/base/tests/test_mail.py
@@ -81,7 +81,7 @@ class TestSanitizer(BaseCase):
self.assertTrue('ha.ckers.org' not in html or 'http://ha.ckers.org/xss.css' in html, 'html_sanitize did not remove a malicious code in %s (%s)' % (content, html))
content = "<!--[if gte IE 4]><SCRIPT>alert('XSS');</SCRIPT><![endif]-->" # down-level hidden block
- self.assertEquals(html_sanitize(content, silent=False), '')
+ self.assertEqual(html_sanitize(content, silent=False), '')
def test_html(self):
sanitized_html = html_sanitize(test_mail_examples.MISC_HTML_SOURCE)
diff --git a/odoo/addons/base/tests/test_mimetypes.py b/odoo/addons/base/tests/test_mimetypes.py
index b5fa3e1ebf8f..1cca62c917b3 100644
--- a/odoo/addons/base/tests/test_mimetypes.py
+++ b/odoo/addons/base/tests/test_mimetypes.py
@@ -45,7 +45,7 @@ class test_guess_mimetype(BaseCase):
content = base64.b64decode(BMP)
mimetype = guess_mimetype(content, default='test')
# mimetype should match image/bmp, image/x-ms-bmp, ...
- self.assertRegexpMatches(mimetype, r'image/.*\bbmp')
+ self.assertRegex(mimetype, r'image/.*\bbmp')
def test_mimetype_jpg(self):
content = base64.b64decode(JPG)
diff --git a/odoo/addons/base/tests/test_osv.py b/odoo/addons/base/tests/test_osv.py
index f79dde6751a0..9b97cfdb0e47 100644
--- a/odoo/addons/base/tests/test_osv.py
+++ b/odoo/addons/base/tests/test_osv.py
@@ -13,9 +13,9 @@ class QueryTestCase(BaseCase):
query.where_clause.append("product_product.template_id = product_template.id")
query.add_join(("product_template", "product_category", "categ_id", "id", "categ_id"), implicit=False, outer=False) # add normal join
query.add_join(("product_product", "res_user", "user_id", "id", "user_id"), implicit=False, outer=True) # outer join
- self.assertEquals(query.get_sql()[0].strip(),
+ self.assertEqual(query.get_sql()[0].strip(),
""""product_product" LEFT JOIN "res_user" as "product_product__user_id" ON ("product_product"."user_id" = "product_product__user_id"."id"),"product_template" JOIN "product_category" as "product_template__categ_id" ON ("product_template"."categ_id" = "product_template__categ_id"."id") """.strip())
- self.assertEquals(query.get_sql()[1].strip(), """product_product.template_id = product_template.id""".strip())
+ self.assertEqual(query.get_sql()[1].strip(), """product_product.template_id = product_template.id""".strip())
def test_query_chained_explicit_joins(self):
query = Query()
@@ -23,9 +23,9 @@ class QueryTestCase(BaseCase):
query.where_clause.append("product_product.template_id = product_template.id")
query.add_join(("product_template", "product_category", "categ_id", "id", "categ_id"), implicit=False, outer=False) # add normal join
query.add_join(("product_template__categ_id", "res_user", "user_id", "id", "user_id"), implicit=False, outer=True) # CHAINED outer join
- self.assertEquals(query.get_sql()[0].strip(),
+ self.assertEqual(query.get_sql()[0].strip(),
""""product_product","product_template" JOIN "product_category" as "product_template__categ_id" ON ("product_template"."categ_id" = "product_template__categ_id"."id") LEFT JOIN "res_user" as "product_template__categ_id__user_id" ON ("product_template__categ_id"."user_id" = "product_template__categ_id__user_id"."id")""".strip())
- self.assertEquals(query.get_sql()[1].strip(), """product_product.template_id = product_template.id""".strip())
+ self.assertEqual(query.get_sql()[1].strip(), """product_product.template_id = product_template.id""".strip())
def test_mixed_query_chained_explicit_implicit_joins(self):
query = Query()
@@ -35,9 +35,9 @@ class QueryTestCase(BaseCase):
query.add_join(("product_template__categ_id", "res_user", "user_id", "id", "user_id"), implicit=False, outer=True) # CHAINED outer join
query.tables.append('"account.account"')
query.where_clause.append("product_category.expense_account_id = account_account.id") # additional implicit join
- self.assertEquals(query.get_sql()[0].strip(),
+ self.assertEqual(query.get_sql()[0].strip(),
""""product_product","product_template" JOIN "product_category" as "product_template__categ_id" ON ("product_template"."categ_id" = "product_template__categ_id"."id") LEFT JOIN "res_user" as "product_template__categ_id__user_id" ON ("product_template__categ_id"."user_id" = "product_template__categ_id__user_id"."id"),"account.account" """.strip())
- self.assertEquals(query.get_sql()[1].strip(), """product_product.template_id = product_template.id AND product_category.expense_account_id = account_account.id""".strip())
+ self.assertEqual(query.get_sql()[1].strip(), """product_product.template_id = product_template.id AND product_category.expense_account_id = account_account.id""".strip())
def test_raise_missing_lhs(self):
query = Query()
diff --git a/odoo/addons/base/tests/test_qweb.py b/odoo/addons/base/tests/test_qweb.py
index 444c2960fe09..9fa00468f06c 100644
--- a/odoo/addons/base/tests/test_qweb.py
+++ b/odoo/addons/base/tests/test_qweb.py
@@ -55,13 +55,13 @@ class TestQWebTField(TransactionCase):
def test_reject_crummy_tags(self):
field = etree.Element('td', {'t-field': u'company.name'})
- with self.assertRaisesRegexp(QWebException, r'^RTE widgets do not work correctly'):
+ with self.assertRaisesRegex(QWebException, r'^RTE widgets do not work correctly'):
self.engine.render(field, {'company': None})
def test_reject_t_tag(self):
field = etree.Element('t', {'t-field': u'company.name'})
- with self.assertRaisesRegexp(QWebException, r'^t-field can not be used on a t element'):
+ with self.assertRaisesRegex(QWebException, r'^t-field can not be used on a t element'):
self.engine.render(field, {'company': None})
def test_render_t_options(self):
diff --git a/odoo/addons/base/tests/test_res_partner_bank.py b/odoo/addons/base/tests/test_res_partner_bank.py
index cbf533802a10..9d19b4ef3952 100644
--- a/odoo/addons/base/tests/test_res_partner_bank.py
+++ b/odoo/addons/base/tests/test_res_partner_bank.py
@@ -14,18 +14,18 @@ class TestResPartnerBank(TransactionCase):
partner_bank_model = self.env['res.partner.bank']
acc_number = " BE-001 2518823 03 "
vals = partner_bank_model.search([('acc_number', '=', acc_number)])
- self.assertEquals(0, len(vals))
+ self.assertEqual(0, len(vals))
partner_bank = partner_bank_model.create({
'acc_number': acc_number,
'partner_id': self.ref('base.res_partner_2'),
'acc_type': 'bank',
})
vals = partner_bank_model.search([('acc_number', '=', acc_number)])
- self.assertEquals(1, len(vals))
- self.assertEquals(partner_bank, vals[0])
+ self.assertEqual(1, len(vals))
+ self.assertEqual(partner_bank, vals[0])
vals = partner_bank_model.search([('acc_number', 'in', [acc_number])])
- self.assertEquals(1, len(vals))
- self.assertEquals(partner_bank, vals[0])
+ self.assertEqual(1, len(vals))
+ self.assertEqual(partner_bank, vals[0])
self.assertEqual(partner_bank.acc_number, acc_number)
@@ -33,19 +33,19 @@ class TestResPartnerBank(TransactionCase):
sanitized_acc_number = 'BE001251882303'
vals = partner_bank_model.search(
[('acc_number', '=', sanitized_acc_number)])
- self.assertEquals(1, len(vals))
- self.assertEquals(partner_bank, vals[0])
+ self.assertEqual(1, len(vals))
+ self.assertEqual(partner_bank, vals[0])
vals = partner_bank_model.search(
[('acc_number', 'in', [sanitized_acc_number])])
- self.assertEquals(1, len(vals))
- self.assertEquals(partner_bank, vals[0])
+ self.assertEqual(1, len(vals))
+ self.assertEqual(partner_bank, vals[0])
self.assertEqual(partner_bank.sanitized_acc_number,
sanitized_acc_number)
# search is case insensitive
vals = partner_bank_model.search(
[('acc_number', '=', sanitized_acc_number.lower())])
- self.assertEquals(1, len(vals))
+ self.assertEqual(1, len(vals))
vals = partner_bank_model.search(
[('acc_number', '=', acc_number.lower())])
- self.assertEquals(1, len(vals))
+ self.assertEqual(1, len(vals))
diff --git a/odoo/addons/base/tests/test_translate.py b/odoo/addons/base/tests/test_translate.py
index ab0a852910a5..1b3ad5ed8dca 100644
--- a/odoo/addons/base/tests/test_translate.py
+++ b/odoo/addons/base/tests/test_translate.py
@@ -18,7 +18,7 @@ class TranslationToolsTestCase(BaseCase):
#print "2:", repr(quoted)
unquoted = unquote("".join(quoted.split('"\n"')))
#print "3:", repr(unquoted)
- self.assertEquals(str, unquoted)
+ self.assertEqual(str, unquoted)
test_string("""test \nall kinds\n \n o\r
\\\\ nope\n\n"
@@ -41,7 +41,7 @@ class TranslationToolsTestCase(BaseCase):
<field name="foo"/>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Form stuff', 'Blah blah blah', 'Put some more text here'])
@@ -50,7 +50,7 @@ class TranslationToolsTestCase(BaseCase):
terms = []
source = "Blah blah blah"
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms, [source])
def test_translate_xml_unicode(self):
@@ -58,7 +58,7 @@ class TranslationToolsTestCase(BaseCase):
terms = []
source = u"Un heureux évènement"
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms, [source])
def test_translate_xml_text_entity(self):
@@ -66,7 +66,7 @@ class TranslationToolsTestCase(BaseCase):
terms = []
source = "Blah&nbsp;blah&nbsp;blah"
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms, [source])
def test_translate_xml_inline1(self):
@@ -78,7 +78,7 @@ class TranslationToolsTestCase(BaseCase):
<field name="foo"/>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Form stuff', 'Blah <i>blah</i> blah', 'Put some <b>more text</b> here'])
@@ -91,7 +91,7 @@ class TranslationToolsTestCase(BaseCase):
<field name="foo"/>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Form stuff', 'Blah <i>blah</i> blah', 'Put <em>some <b>more text</b></em> here'])
@@ -108,7 +108,7 @@ class TranslationToolsTestCase(BaseCase):
</div>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Form stuff', 'Blah blah blah'])
@@ -122,7 +122,7 @@ class TranslationToolsTestCase(BaseCase):
</div>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Form stuff', '<span class="fa fa-globe" title="Title stuff"/>'])
@@ -136,7 +136,7 @@ class TranslationToolsTestCase(BaseCase):
</div>
</form>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms, ['Form stuff'])
def test_translate_xml_t(self):
@@ -148,7 +148,7 @@ class TranslationToolsTestCase(BaseCase):
stuff after
</t>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['stuff before', 'stuff after'])
@@ -161,7 +161,7 @@ class TranslationToolsTestCase(BaseCase):
stuff after
</div>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['stuff before', 'stuff after'])
@@ -173,7 +173,7 @@ class TranslationToolsTestCase(BaseCase):
<attribute name="option">Do not translate this</attribute>
</field>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['Translate this'])
@@ -190,7 +190,7 @@ class TranslationToolsTestCase(BaseCase):
</ul>
</t>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms,
['<span class="oe_menu_text">Blah</span>'])
@@ -205,10 +205,10 @@ class TranslationToolsTestCase(BaseCase):
</t>
</Invoice>"""
result = xml_translate(terms.append, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
self.assertItemsEqual(terms, ['Oasis'])
result = xml_translate(lambda term: term, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
def test_translate_xml_invalid_translations(self):
""" Test xml_translate() with invalid translations. """
@@ -226,21 +226,21 @@ class TranslationToolsTestCase(BaseCase):
<field name="foo"/>
</form>"""
result = xml_translate(translations.get, source)
- self.assertEquals(result, expect)
+ self.assertEqual(result, expect)
def test_translate_html(self):
""" Test html_translate(). """
source = """<blockquote>A <h2>B</h2> C</blockquote>"""
result = html_translate(lambda term: term, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
def test_translate_html_i(self):
""" Test xml_translate() and html_translate() with <i> elements. """
source = """<p>A <i class="fa-check"></i> B</p>"""
result = xml_translate(lambda term: term, source)
- self.assertEquals(result, """<p>A <i class="fa-check"/> B</p>""")
+ self.assertEqual(result, """<p>A <i class="fa-check"/> B</p>""")
result = html_translate(lambda term: term, source)
- self.assertEquals(result, source)
+ self.assertEqual(result, source)
class TestTranslation(TransactionCase):
diff --git a/odoo/addons/base/wizard/base_export_language.py b/odoo/addons/base/wizard/base_export_language.py
index 93284f54e8ca..b0d09608df61 100644
--- a/odoo/addons/base/wizard/base_export_language.py
+++ b/odoo/addons/base/wizard/base_export_language.py
@@ -36,7 +36,7 @@ class BaseLanguageExport(models.TransientModel):
with contextlib.closing(io.BytesIO()) as buf:
tools.trans_export(lang, mods, buf, this.format, self._cr)
- out = base64.encodestring(buf.getvalue())
+ out = base64.encodebytes(buf.getvalue())
filename = 'new'
if lang:
diff --git a/odoo/addons/base/wizard/base_import_language.py b/odoo/addons/base/wizard/base_import_language.py
index c0d78c462991..461c95958c36 100644
--- a/odoo/addons/base/wizard/base_import_language.py
+++ b/odoo/addons/base/wizard/base_import_language.py
@@ -31,7 +31,7 @@ class BaseLanguageImport(models.TransientModel):
this = this.with_context(overwrite=this.overwrite)
with TemporaryFile('wb+') as buf:
try:
- buf.write(base64.decodestring(this.data))
+ buf.write(base64.decodebytes(this.data))
# now we determine the file format
buf.seek(0)
diff --git a/odoo/addons/test_assetsbundle/tests/test_assetsbundle.py b/odoo/addons/test_assetsbundle/tests/test_assetsbundle.py
index 6e74fb0fc993..557b1396a049 100644
--- a/odoo/addons/test_assetsbundle/tests/test_assetsbundle.py
+++ b/odoo/addons/test_assetsbundle/tests/test_assetsbundle.py
@@ -64,15 +64,15 @@ class TestJavascriptAssetsBundle(FileTouchable):
self.bundle = self._get_asset(self.jsbundle_xmlid, env=self.env)
# there shouldn't be any attachment associated to this bundle
- self.assertEquals(len(self._any_ira_for_bundle('js')), 0)
- self.assertEquals(len(self.bundle.get_attachments('js')), 0)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 0)
+ self.assertEqual(len(self.bundle.get_attachments('js')), 0)
# trigger the first generation and, thus, the first save in database
self.bundle.js()
# there should be one attachment associated to this bundle
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
- self.assertEquals(len(self.bundle.get_attachments('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self.bundle.get_attachments('js')), 1)
def test_02_access(self):
""" Checks that the bundle's cache is working, i.e. that the bundle creates only one
@@ -81,7 +81,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
bundle0 = self._get_asset(self.jsbundle_xmlid)
bundle0.js()
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
version0 = bundle0.version
ira0 = self._any_ira_for_bundle('js')
@@ -90,14 +90,14 @@ class TestJavascriptAssetsBundle(FileTouchable):
bundle1 = self._get_asset(self.jsbundle_xmlid)
bundle1.js()
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
version1 = bundle1.version
ira1 = self._any_ira_for_bundle('js')
date1 = ira1.create_date
- self.assertEquals(version0, version1)
- self.assertEquals(date0, date1)
+ self.assertEqual(version0, version1)
+ self.assertEqual(date0, date1)
def test_03_date_invalidation(self):
""" Checks that a bundle is invalidated when one of its assets' modification date is changed.
@@ -114,11 +114,11 @@ class TestJavascriptAssetsBundle(FileTouchable):
bundle1.js()
last_modified1 = bundle1.last_modified
version1 = bundle1.version
- self.assertNotEquals(last_modified0, last_modified1)
- self.assertNotEquals(version0, version1)
+ self.assertNotEqual(last_modified0, last_modified1)
+ self.assertNotEqual(version0, version1)
# check if the previous attachment is correctly cleaned
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
def test_04_content_invalidation(self):
""" Checks that a bundle is invalidated when its content is modified by adding a file to
@@ -129,7 +129,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
files0 = bundle0.files
version0 = bundle0.version
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
view_arch = """
<data>
@@ -151,11 +151,11 @@ class TestJavascriptAssetsBundle(FileTouchable):
files1 = bundle1.files
version1 = bundle1.version
- self.assertNotEquals(files0, files1)
- self.assertNotEquals(version0, version1)
+ self.assertNotEqual(files0, files1)
+ self.assertNotEqual(version0, version1)
# check if the previous attachment are correctly cleaned
- self.assertEquals(len(self._any_ira_for_bundle('js')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 1)
def test_05_debug(self):
""" Checks that a bundle rendered in debug mode outputs non-minified assets.
@@ -167,14 +167,14 @@ class TestJavascriptAssetsBundle(FileTouchable):
self.assertIn('/test_assetsbundle/static/src/js/test_jsfile1.js', content)
# there shouldn't be any assets created in debug mode
- self.assertEquals(len(self._any_ira_for_bundle('js')), 0)
+ self.assertEqual(len(self._any_ira_for_bundle('js')), 0)
def test_08_css_generation3(self):
# self.cssbundle_xlmid contains 3 rules
self.bundle = self._get_asset(self.cssbundle_xmlid)
self.bundle.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
- self.assertEquals(len(self.bundle.get_attachments('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self.bundle.get_attachments('css')), 1)
def test_09_css_access(self):
""" Checks that the bundle's cache is working, i.e. that a bundle creates only enough
@@ -183,7 +183,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
bundle0 = self._get_asset(self.cssbundle_xmlid)
bundle0.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
version0 = bundle0.version
ira0 = self._any_ira_for_bundle('css')
@@ -192,14 +192,14 @@ class TestJavascriptAssetsBundle(FileTouchable):
bundle1 = self._get_asset(self.cssbundle_xmlid)
bundle1.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
version1 = bundle1.version
ira1 = self._any_ira_for_bundle('css')
date1 = ira1.create_date
- self.assertEquals(version0, version1)
- self.assertEquals(date0, date1)
+ self.assertEqual(version0, version1)
+ self.assertEqual(date0, date1)
def test_11_css_content_invalidation(self):
""" Checks that a bundle is invalidated when its content is modified by adding a file to
@@ -210,7 +210,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
files0 = bundle0.files
version0 = bundle0.version
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
view_arch = """
<data>
@@ -232,11 +232,11 @@ class TestJavascriptAssetsBundle(FileTouchable):
files1 = bundle1.files
version1 = bundle1.version
- self.assertNotEquals(files0, files1)
- self.assertNotEquals(version0, version1)
+ self.assertNotEqual(files0, files1)
+ self.assertNotEqual(version0, version1)
# check if the previous attachment are correctly cleaned
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
def test_12_css_debug(self):
""" Check that a bundle in debug mode outputs non-minified assets.
@@ -248,7 +248,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
self.assertIn('/test_assetsbundle/static/src/css/test_cssfile1.css', content)
# there shouldn't be any assets created in debug mode
- self.assertEquals(len(self._any_ira_for_bundle('css')), 0)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 0)
def test_14_duplicated_css_assets(self):
""" Checks that if the bundle's ir.attachment record is duplicated, the bundle is only sourced once. This could
@@ -256,13 +256,13 @@ class TestJavascriptAssetsBundle(FileTouchable):
"""
bundle0 = self._get_asset(self.cssbundle_xmlid)
bundle0.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
# duplicate the asset bundle
ira0 = self._any_ira_for_bundle('css')
ira1 = ira0.copy()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 2)
- self.assertEquals(ira0.store_fname, ira1.store_fname)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 2)
+ self.assertEqual(ira0.store_fname, ira1.store_fname)
# the ir.attachment records should be deduplicated in the bundle's content
nodes = bundle0.to_node()
@@ -278,15 +278,15 @@ class TestJavascriptAssetsBundle(FileTouchable):
self.bundle = self._get_asset(self.cssbundle_xmlid, env=self.env(context={'lang': 'ar_SY'}))
# there shouldn't be any attachment associated to this bundle
- self.assertEquals(len(self._any_ira_for_bundle('css', lang='ar_SY')), 0)
- self.assertEquals(len(self.bundle.get_attachments('css')), 0)
+ self.assertEqual(len(self._any_ira_for_bundle('css', lang='ar_SY')), 0)
+ self.assertEqual(len(self.bundle.get_attachments('css')), 0)
# trigger the first generation and, thus, the first save in database
self.bundle.css()
# there should be one attachment associated to this bundle
- self.assertEquals(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
- self.assertEquals(len(self.bundle.get_attachments('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
+ self.assertEqual(len(self.bundle.get_attachments('css')), 1)
def test_16_ltr_and_rtl_css_access(self):
""" Checks that the bundle's cache is working, i.e. that the bundle creates only one
@@ -297,7 +297,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
ltr_bundle0 = self._get_asset(self.cssbundle_xmlid)
ltr_bundle0.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
ltr_version0 = ltr_bundle0.version
ltr_ira0 = self._any_ira_for_bundle('css')
@@ -306,20 +306,20 @@ class TestJavascriptAssetsBundle(FileTouchable):
ltr_bundle1 = self._get_asset(self.cssbundle_xmlid)
ltr_bundle1.css()
- self.assertEquals(len(self._any_ira_for_bundle('css')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css')), 1)
ltr_version1 = ltr_bundle1.version
ltr_ira1 = self._any_ira_for_bundle('css')
ltr_date1 = ltr_ira1.create_date
- self.assertEquals(ltr_version0, ltr_version1)
- self.assertEquals(ltr_date0, ltr_date1)
+ self.assertEqual(ltr_version0, ltr_version1)
+ self.assertEqual(ltr_date0, ltr_date1)
# Assets access for ar_SY language
rtl_bundle0 = self._get_asset(self.cssbundle_xmlid, env=self.env(context={'lang': 'ar_SY'}))
rtl_bundle0.css()
- self.assertEquals(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
rtl_version0 = rtl_bundle0.version
rtl_ira0 = self._any_ira_for_bundle('css', lang='ar_SY')
@@ -328,23 +328,23 @@ class TestJavascriptAssetsBundle(FileTouchable):
rtl_bundle1 = self._get_asset(self.cssbundle_xmlid, env=self.env(context={'lang': 'ar_SY'}))
rtl_bundle1.css()
- self.assertEquals(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
+ self.assertEqual(len(self._any_ira_for_bundle('css', lang='ar_SY')), 1)
rtl_version1 = rtl_bundle1.version
rtl_ira1 = self._any_ira_for_bundle('css', lang='ar_SY')
rtl_date1 = rtl_ira1.create_date
- self.assertEquals(rtl_version0, rtl_version1)
- self.assertEquals(rtl_date0, rtl_date1)
+ self.assertEqual(rtl_version0, rtl_version1)
+ self.assertEqual(rtl_date0, rtl_date1)
# Checks rtl and ltr bundles are different
- self.assertNotEquals(ltr_ira1.id, rtl_ira1.id)
+ self.assertNotEqual(ltr_ira1.id, rtl_ira1.id)
# Check two bundles are available, one for ltr and one for rtl
css_bundles = self.env['ir.attachment'].search([
('url', '=like', '/web/content/%-%/{0}%.{1}'.format(self.cssbundle_xmlid, 'css'))
])
- self.assertEquals(len(css_bundles), 2)
+ self.assertEqual(len(css_bundles), 2)
def test_17_css_bundle_date_invalidation(self):
""" Checks that both css bundles are invalidated when one of its assets' modification date is changed
@@ -371,8 +371,8 @@ class TestJavascriptAssetsBundle(FileTouchable):
ltr_last_modified1 = ltr_bundle1.last_modified
ltr_version1 = ltr_bundle1.version
ltr_ira1 = self._any_ira_for_bundle('css')
- self.assertNotEquals(ltr_last_modified0, ltr_last_modified1)
- self.assertNotEquals(ltr_version0, ltr_version1)
+ self.assertNotEqual(ltr_last_modified0, ltr_last_modified1)
+ self.assertNotEqual(ltr_version0, ltr_version1)
rtl_bundle1 = self._get_asset(self.cssbundle_xmlid, env=self.env(context={'lang': 'ar_SY'}))
@@ -380,17 +380,17 @@ class TestJavascriptAssetsBundle(FileTouchable):
rtl_last_modified1 = rtl_bundle1.last_modified
rtl_version1 = rtl_bundle1.version
rtl_ira1 = self._any_ira_for_bundle('css', lang='ar_SY')
- self.assertNotEquals(rtl_last_modified0, rtl_last_modified1)
- self.assertNotEquals(rtl_version0, rtl_version1)
+ self.assertNotEqual(rtl_last_modified0, rtl_last_modified1)
+ self.assertNotEqual(rtl_version0, rtl_version1)
# Checks rtl and ltr bundles are different
- self.assertNotEquals(ltr_ira1.id, rtl_ira1.id)
+ self.assertNotEqual(ltr_ira1.id, rtl_ira1.id)
# check if the previous attachment is correctly cleaned
css_bundles = self.env['ir.attachment'].search([
('url', '=like', '/web/content/%-%/{0}%.{1}'.format(self.cssbundle_xmlid, 'css'))
])
- self.assertEquals(len(css_bundles), 2)
+ self.assertEqual(len(css_bundles), 2)
def test_18_css_bundle_content_invalidation(self):
""" Checks that a bundle is invalidated when its content is modified by adding a file to
@@ -410,7 +410,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
css_bundles = self.env['ir.attachment'].search([
('url', '=like', '/web/content/%-%/{0}%.{1}'.format(self.cssbundle_xmlid, 'css'))
])
- self.assertEquals(len(css_bundles), 2)
+ self.assertEqual(len(css_bundles), 2)
view_arch = """
<data>
@@ -433,8 +433,8 @@ class TestJavascriptAssetsBundle(FileTouchable):
ltr_version1 = ltr_bundle1.version
ltr_ira1 = self._any_ira_for_bundle('css')
- self.assertNotEquals(ltr_files0, ltr_files1)
- self.assertNotEquals(ltr_version0, ltr_version1)
+ self.assertNotEqual(ltr_files0, ltr_files1)
+ self.assertNotEqual(ltr_version0, ltr_version1)
rtl_bundle1 = self._get_asset(self.cssbundle_xmlid, env=self.env(context={'check_view_ids': view.ids, 'lang': 'ar_SY'}))
rtl_bundle1.css()
@@ -442,17 +442,17 @@ class TestJavascriptAssetsBundle(FileTouchable):
rtl_version1 = rtl_bundle1.version
rtl_ira1 = self._any_ira_for_bundle('css', lang='ar_SY')
- self.assertNotEquals(rtl_files0, rtl_files1)
- self.assertNotEquals(rtl_version0, rtl_version1)
+ self.assertNotEqual(rtl_files0, rtl_files1)
+ self.assertNotEqual(rtl_version0, rtl_version1)
# Checks rtl and ltr bundles are different
- self.assertNotEquals(ltr_ira1.id, rtl_ira1.id)
+ self.assertNotEqual(ltr_ira1.id, rtl_ira1.id)
# check if the previous attachment are correctly cleaned
css_bundles = self.env['ir.attachment'].search([
('url', '=like', '/web/content/%-%/{0}%.{1}'.format(self.cssbundle_xmlid, 'css'))
])
- self.assertEquals(len(css_bundles), 2)
+ self.assertEqual(len(css_bundles), 2)
def test_19_css_in_debug_assets(self):
""" Checks that a bundle rendered in debug mode(assets) with right to left language direction stores css files in assets bundle.
@@ -468,12 +468,12 @@ class TestJavascriptAssetsBundle(FileTouchable):
css_bundle = self.env['ir.attachment'].search([
('url', '=', '/test_assetsbundle/static/src/css/test_cssfile1/rtl/{0}.css'.format(self.cssbundle_xmlid))
])
- self.assertEquals(len(css_bundle), 1)
+ self.assertEqual(len(css_bundle), 1)
def test_20_exteral_lib_assets(self):
html = self.env['ir.ui.view'].render_template('test_assetsbundle.template2')
attachments = self.env['ir.attachment'].search([('url', '=like', '/web/content/%-%/test_assetsbundle.bundle4.%')])
- self.assertEquals(len(attachments), 2)
+ self.assertEqual(len(attachments), 2)
self.assertEqual(html.strip(), ("""<!DOCTYPE html>
<html>
<head>
@@ -492,7 +492,7 @@ class TestJavascriptAssetsBundle(FileTouchable):
def test_21_exteral_lib_assets_debug_mode(self):
html = self.env['ir.ui.view'].render_template('test_assetsbundle.template2', {"debug": "assets"})
attachments = self.env['ir.attachment'].search([('url', '=like', '/web/content/%-%/test_assetsbundle.bundle4.%')])
- self.assertEquals(len(attachments), 0)
+ self.assertEqual(len(attachments), 0)
self.assertEqual(html.strip(), ("""<!DOCTYPE html>
<html>
<head>
@@ -578,8 +578,8 @@ class TestAssetsBundleWithIRAMock(FileTouchable):
def _bundle(self, asset, should_create, should_unlink):
self.counter.clear()
asset.to_node(debug='assets')
- self.assertEquals(self.counter['create'], int(should_create))
- self.assertEquals(self.counter['unlink'], int(should_unlink))
+ self.assertEqual(self.counter['create'], int(should_create))
+ self.assertEqual(self.counter['unlink'], int(should_unlink))
def test_01_debug_mode_assets(self):
""" Checks that the ir.attachments records created for compiled assets in debug mode
diff --git a/odoo/addons/test_lint/tests/test_pylint.py b/odoo/addons/test_lint/tests/test_pylint.py
index 8e5e69fa351f..9e7b3ab03975 100644
--- a/odoo/addons/test_lint/tests/test_pylint.py
+++ b/odoo/addons/test_lint/tests/test_pylint.py
@@ -30,6 +30,7 @@ class TestPyLint(TransactionCase):
'unreachable',
'mixed-indentation',
+ 'deprecated-method',
]
BAD_FUNCTIONS = [
@@ -43,7 +44,7 @@ class TestPyLint(TransactionCase):
] + list(tools.SUPPORTED_DEBUGGER)
def _skip_test(self, reason):
- _logger.warn(reason)
+ _logger.warning(reason)
self.skipTest(reason)
def test_pylint(self):
diff --git a/odoo/addons/test_performance/tests/test_performance.py b/odoo/addons/test_performance/tests/test_performance.py
index bfd2cdcee373..1db2e33f6d25 100644
--- a/odoo/addons/test_performance/tests/test_performance.py
+++ b/odoo/addons/test_performance/tests/test_performance.py
@@ -176,7 +176,7 @@ class TestPerformance(TransactionCase):
# This write() will raise because of the unique index if the unlink() is
# not performed before the create()
rec.write({'line_ids': [(5,)] + [(0, 0, {'value': val}) for val in range(6)]})
- self.assertEquals(len(rec.line_ids), 6)
+ self.assertEqual(len(rec.line_ids), 6)
@mute_logger('odoo.models.unlink')
@users('__system__', 'demo')
diff --git a/odoo/addons/test_testing_utilities/tests/test_form_impl.py b/odoo/addons/test_testing_utilities/tests/test_form_impl.py
index c0e5093fd3b0..838103157b66 100644
--- a/odoo/addons/test_testing_utilities/tests/test_form_impl.py
+++ b/odoo/addons/test_testing_utilities/tests/test_form_impl.py
@@ -42,7 +42,7 @@ class TestBasic(TransactionCase):
def test_required(self):
f = Form(self.env['test_testing_utilities.a'])
# f1 no default & no value => should fail
- with self.assertRaisesRegexp(AssertionError, 'f1 is a required field'):
+ with self.assertRaisesRegex(AssertionError, 'f1 is a required field'):
f.save()
# set f1 and unset f2 => should work
f.f1 = '1'
diff --git a/odoo/addons/test_translation_import/tests/test_term_count.py b/odoo/addons/test_translation_import/tests/test_term_count.py
index 7526049f4e83..fb98e78661f9 100644
--- a/odoo/addons/test_translation_import/tests/test_term_count.py
+++ b/odoo/addons/test_translation_import/tests/test_term_count.py
@@ -151,7 +151,7 @@ class TestTermCount(common.TransactionCase):
def test_import_from_po_file(self):
"""Test the import from a single po file works"""
with file_open('test_translation_import/i18n/tlh.po', 'rb') as f:
- po_file = base64.encodestring(f.read())
+ po_file = base64.encodebytes(f.read())
import_tlh = self.env["base.language.import"].create({
'name': 'Klingon',
@@ -174,7 +174,7 @@ class TestTermCount(common.TransactionCase):
def test_lazy_translation(self):
"""Test the import from a single po file works"""
with file_open('test_translation_import/i18n/tlh.po', 'rb') as f:
- po_file = base64.encodestring(f.read())
+ po_file = base64.encodebytes(f.read())
import_tlh = self.env["base.language.import"].create({
'name': 'Klingon',
@@ -200,7 +200,7 @@ class TestTermCount(common.TransactionCase):
def test_import_from_csv_file(self):
"""Test the import from a single CSV file works"""
with file_open('test_translation_import/i18n/dot.csv', 'rb') as f:
- po_file = base64.encodestring(f.read())
+ po_file = base64.encodebytes(f.read())
import_tlh = self.env["base.language.import"].create({
'name': 'Dothraki',
diff --git a/odoo/api.py b/odoo/api.py
index 4015156f1a30..dd0010db9f5d 100644
--- a/odoo/api.py
+++ b/odoo/api.py
@@ -43,7 +43,7 @@ import logging
from collections import defaultdict, Mapping
from contextlib import contextmanager
from copy import deepcopy
-from inspect import getargspec
+from inspect import signature
from pprint import pformat
from weakref import WeakSet
@@ -280,7 +280,7 @@ def downgrade(method, value, self, args, kwargs):
if not spec:
return value
_, convert, _ = spec
- if convert and len(getargspec(convert).args) > 1:
+ if convert and len(signature(convert).parameters) > 1:
return convert(self, value, *args, **kwargs)
elif convert:
return convert(value)
diff --git a/odoo/exceptions.py b/odoo/exceptions.py
index 37fde75a8455..75e8749b0288 100644
--- a/odoo/exceptions.py
+++ b/odoo/exceptions.py
@@ -22,7 +22,7 @@ class except_orm(Exception):
def __init__(self, name, value=None):
if type(self) == except_orm:
caller = frame_codeinfo(currentframe(), 1)
- _logger.warn('except_orm is deprecated. Please use specific exceptions like UserError or AccessError. Caller: %s:%s', *caller)
+ _logger.warning('except_orm is deprecated. Please use specific exceptions like UserError or AccessError. Caller: %s:%s', *caller)
self.name = name
self.value = value
self.args = (name, value)
diff --git a/odoo/http.py b/odoo/http.py
index 90acbbe7cf7e..a4c48f67795e 100644
--- a/odoo/http.py
+++ b/odoo/http.py
@@ -505,9 +505,14 @@ def route(route=None, **kw):
@functools.wraps(f)
def response_wrap(*args, **kw):
# if controller cannot be called with extra args (utm, debug, ...), call endpoint ignoring them
- spec = inspect.getargspec(f)
- if not spec.keywords:
- ignored = ['<%s=%s>' % (k, kw.pop(k)) for k in list(kw) if k not in spec.args]
+ params = inspect.signature(f).parameters.values()
+ is_kwargs = lambda p: p.kind == inspect.Parameter.VAR_KEYWORD
+ if not any(is_kwargs(p) for p in params): # missing **kw
+ is_keyword_compatible = lambda p: p.kind in (
+ inspect.Parameter.POSITIONAL_OR_KEYWORD,
+ inspect.Parameter.KEYWORD_ONLY)
+ fargs = {p.name for p in params if is_keyword_compatible(p)}
+ ignored = ['<%s=%s>' % (k, kw.pop(k)) for k in list(kw) if k not in fargs]
if ignored:
_logger.info("<function %s.%s> called ignoring args %s" % (f.__module__, f.__name__, ', '.join(ignored)))
@@ -525,7 +530,7 @@ def route(route=None, **kw):
response.set_default()
return response
- _logger.warn("<function %s.%s> returns an invalid response type for an http request" % (f.__module__, f.__name__))
+ _logger.warning("<function %s.%s> returns an invalid response type for an http request" % (f.__module__, f.__name__))
return response
response_wrap.routing = routing
response_wrap.original_func = f
@@ -775,10 +780,10 @@ class HttpRequest(WebRequest):
token = self.params.pop('csrf_token', None)
if not self.validate_csrf(token):
if token is not None:
- _logger.warn("CSRF validation failed on path '%s'",
+ _logger.warning("CSRF validation failed on path '%s'",
request.httprequest.path)
else:
- _logger.warn("""No CSRF validation token provided for path '%s'
+ _logger.warning("""No CSRF validation token provided for path '%s'
Odoo URLs are CSRF-protected by default (when accessed with unsafe
HTTP methods). See
@@ -873,12 +878,12 @@ class ControllerType(type):
parent_routing_type = getattr(parent[0], k).original_func.routing_type if parent else routing_type or 'http'
if routing_type is not None and routing_type is not parent_routing_type:
routing_type = parent_routing_type
- _logger.warn("Subclass re-defines <function %s.%s.%s> with different type than original."
+ _logger.warning("Subclass re-defines <function %s.%s.%s> with different type than original."
" Will use original type: %r" % (cls.__module__, cls.__name__, k, parent_routing_type))
v.original_func.routing_type = routing_type or parent_routing_type
- spec = inspect.getargspec(v.original_func)
- first_arg = spec.args[1] if len(spec.args) >= 2 else None
+ sign = inspect.signature(v.original_func)
+ first_arg = list(sign.parameters)[1] if len(sign.parameters) >= 2 else None
if first_arg in ["req", "request"]:
v._first_arg_is_req = True
@@ -1338,7 +1343,7 @@ class Root(object):
# Check if session.db is legit
if db:
if db not in db_filter([db], httprequest=httprequest):
- _logger.warn("Logged into database '%s', but dbfilter "
+ _logger.warning("Logged into database '%s', but dbfilter "
"rejects it; logging session out.", db)
httprequest.session.logout()
db = None
diff --git a/odoo/models.py b/odoo/models.py
index 439041dd03e8..5291726f3676 100644
--- a/odoo/models.py
+++ b/odoo/models.py
@@ -1891,7 +1891,7 @@ class BaseModel(MetaModel('DummyModel', (object,), {'_register': False})):
orderby_terms.append(' '.join(order_split))
else:
# Cannot order by a field that will not appear in the results (needs to be grouped or aggregated)
- _logger.warn('%s: read_group order by `%s` ignored, cannot sort on empty columns (not grouped/aggregated)',
+ _logger.warning('%s: read_group order by `%s` ignored, cannot sort on empty columns (not grouped/aggregated)',
self._name, order_part)
return groupby_terms, orderby_terms
diff --git a/odoo/modules/module.py b/odoo/modules/module.py
index 2c06bca742b8..aef985230c86 100644
--- a/odoo/modules/module.py
+++ b/odoo/modules/module.py
@@ -456,7 +456,7 @@ def get_test_modules(module):
_logger.exception('Can not `import %s`.', module)
return []
if hasattr(mod, 'fast_suite') or hasattr(mod, 'checks'):
- _logger.warn(
+ _logger.warning(
"Found deprecated fast_suite or checks attribute in test module "
"%s. These have no effect in or after version 8.0.",
mod.__name__)
diff --git a/odoo/service/server.py b/odoo/service/server.py
index 490d204d1668..574d569fbca1 100644
--- a/odoo/service/server.py
+++ b/odoo/service/server.py
@@ -657,7 +657,7 @@ class PreforkServer(CommonServer):
self.queue.append(sig)
self.pipe_ping(self.pipe)
else:
- _logger.warn("Dropping signal: %s", sig)
+ _logger.warning("Dropping signal: %s", sig)
def worker_spawn(self, klass, workers_registry):
self.generation += 1
diff --git a/odoo/tools/cache.py b/odoo/tools/cache.py
index e23f7ea11249..2d50b51aa946 100644
--- a/odoo/tools/cache.py
+++ b/odoo/tools/cache.py
@@ -4,7 +4,7 @@
# decorator makes wrappers that have the same API as their wrapped function
from collections import defaultdict
from decorator import decorator
-from inspect import formatargspec, getargspec
+from inspect import signature
import logging
unsafe_eval = eval
@@ -64,7 +64,7 @@ class ormcache(object):
""" Determine the function that computes a cache key from arguments. """
if self.skiparg is None:
# build a string that represents function code and evaluate it
- args = formatargspec(*getargspec(self.method))[1:-1]
+ args = str(signature(self.method))[1:-1]
if self.args:
code = "lambda %s: (%s,)" % (args, ", ".join(self.args))
else:
@@ -90,7 +90,7 @@ class ormcache(object):
value = d[key] = self.method(*args, **kwargs)
return value
except TypeError:
- _logger.warn("cache lookup error on %r", key, exc_info=True)
+ _logger.warning("cache lookup error on %r", key, exc_info=True)
counter.err += 1
return self.method(*args, **kwargs)
@@ -113,9 +113,9 @@ class ormcache_context(ormcache):
""" Determine the function that computes a cache key from arguments. """
assert self.skiparg is None, "ormcache_context() no longer supports skiparg"
# build a string that represents function code and evaluate it
- spec = getargspec(self.method)
- args = formatargspec(*spec)[1:-1]
- cont_expr = "(context or {})" if 'context' in spec.args else "self._context"
+ sign = signature(self.method)
+ args = str(sign)[1:-1]
+ cont_expr = "(context or {})" if 'context' in sign.parameters else "self._context"
keys_expr = "tuple(%s.get(k) for k in %r)" % (cont_expr, self.keys)
if self.args:
code = "lambda %s: (%s, %s)" % (args, ", ".join(self.args), keys_expr)
@@ -142,13 +142,13 @@ class ormcache_multi(ormcache):
super(ormcache_multi, self).determine_key()
# key_multi computes the extra element added to the key
- spec = getargspec(self.method)
- args = formatargspec(*spec)[1:-1]
+ sign = signature(self.method)
+ args = str(sign)[1:-1]
code_multi = "lambda %s: %s" % (args, self.multi)
self.key_multi = unsafe_eval(code_multi)
# self.multi_pos is the position of self.multi in args
- self.multi_pos = spec.args.index(self.multi)
+ self.multi_pos = list(sign.parameters).index(self.multi)
def lookup(self, method, *args, **kwargs):
d, key0, counter = self.lru(args[0])
diff --git a/odoo/tools/convert.py b/odoo/tools/convert.py
index 5ace904749b5..f876ecb4caee 100644
--- a/odoo/tools/convert.py
+++ b/odoo/tools/convert.py
@@ -787,10 +787,10 @@ def convert_xml_import(cr, module, xmlfile, idref=None, mode='init', noupdate=Fa
_logger.exception("The XML file '%s' does not fit the required schema !", xmlfile.name)
if jingtrang:
p = subprocess.run(['pyjing', schema, xmlfile.name], stdout=subprocess.PIPE)
- _logger.warn(p.stdout.decode())
+ _logger.warning(p.stdout.decode())
else:
for e in relaxng.error_log:
- _logger.warn(e)
+ _logger.warning(e)
_logger.info("Install 'jingtrang' for more precise and useful validation messages.")
raise
--
GitLab