chore(release): Bumped to Version 16.11.0

# [16.11.0](https://github.com/frappe/erpnext/compare/v16.10.1...v16.11.0) (2026-03-23)

### Bug Fixes

* Adding validation for operation time in BOM ([c38b252](c38b252289))
* batch validation for subcontracting receipt ([604739d](604739d1dc))
* check for `submit` permissions instead of `write` permissions when updating status (backport [#53697](https://github.com/frappe/erpnext/issues/53697)) ([#53703](https://github.com/frappe/erpnext/issues/53703)) ([cd1dfee](cd1dfeeab3))
* check posting_date in args (backport [#53303](https://github.com/frappe/erpnext/issues/53303)) ([#53612](https://github.com/frappe/erpnext/issues/53612)) ([f394ead](f394ead878))
* consider returned qty in subcontracting report (backport [#53616](https://github.com/frappe/erpnext/issues/53616)) ([#53621](https://github.com/frappe/erpnext/issues/53621)) ([7edcef1](7edcef1248))
* deadlock issue for SLE ([de41aba](de41abaaf2))
* do not overwrite expense account in stock entry (backport [#53658](https://github.com/frappe/erpnext/issues/53658)) ([#53661](https://github.com/frappe/erpnext/issues/53661)) ([077f397](077f39721a))
* do not update float precision on setup ([0af4cd9](0af4cd9098))
* ignore cost center (backport [#53063](https://github.com/frappe/erpnext/issues/53063)) ([#53614](https://github.com/frappe/erpnext/issues/53614)) ([2ccac6c](2ccac6c479))
* incorrect sle calculation when doc has project ([#53599](https://github.com/frappe/erpnext/issues/53599)) ([55bad49](55bad49cf0))
* **manufacturing:** update non-stock item dict (backport [#53689](https://github.com/frappe/erpnext/issues/53689)) ([#53699](https://github.com/frappe/erpnext/issues/53699)) ([0d9af60](0d9af60f8a))
* merge conflict ([f1c93d4](f1c93d4b98))
* **payment_schedule:** using `show_alert` instead of `msgprint` for non-selection of payment schedule (backport [#53623](https://github.com/frappe/erpnext/issues/53623)) ([#53631](https://github.com/frappe/erpnext/issues/53631)) ([a94bf6d](a94bf6db06))
* PO should not be required for internal transfers (backport [#53681](https://github.com/frappe/erpnext/issues/53681)) ([#53684](https://github.com/frappe/erpnext/issues/53684)) ([5f9533f](5f9533f089))
* python error in manufacture entry if transfer against is job card (backport [#53615](https://github.com/frappe/erpnext/issues/53615)) ([#53618](https://github.com/frappe/erpnext/issues/53618)) ([10a40a6](10a40a6d9b))
* set customer details on customer creation at login (backport [#53509](https://github.com/frappe/erpnext/issues/53509)) ([#53629](https://github.com/frappe/erpnext/issues/53629)) ([5b4e3e9](5b4e3e92df))
* shipping rule applied twice on non stock items (backport [#53655](https://github.com/frappe/erpnext/issues/53655)) ([#53687](https://github.com/frappe/erpnext/issues/53687)) ([9805745](9805745a66))
* stock queue for SABB ([f570a4c](f570a4cb5d))
* **stock:** add company filter while fetching batches (backport [#53369](https://github.com/frappe/erpnext/issues/53369)) ([#53581](https://github.com/frappe/erpnext/issues/53581)) ([91ee45a](91ee45a698))
* **stock:** fix email error message (backport [#53606](https://github.com/frappe/erpnext/issues/53606)) ([#53633](https://github.com/frappe/erpnext/issues/53633)) ([48e8944](48e8944a86))
* **stock:** handle NoneType error (backport [#53593](https://github.com/frappe/erpnext/issues/53593)) ([#53627](https://github.com/frappe/erpnext/issues/53627)) ([2d1dd03](2d1dd03483))
* test case ([aac60b4](aac60b4c13))
* **test:** Use the system-configured float precision ([dd7cc56](dd7cc56dfe))
* **trends:** added validation for `period_based_on` filter (backport [#53690](https://github.com/frappe/erpnext/issues/53690)) ([#53692](https://github.com/frappe/erpnext/issues/53692)) ([9787777](9787777cbd))
* use correct test class ([1efbc60](1efbc60df1))
* validate permission before updating status (backport [#53651](https://github.com/frappe/erpnext/issues/53651)) ([#53653](https://github.com/frappe/erpnext/issues/53653)) ([7ebed91](7ebed912cf))

### Features

* add cost center field to the stock entry accounting dimension tab ([50da693](50da6937e1))

.github/workflows/run-individual-tests.yml

@@ -4,8 +4,8 @@ on:
   workflow_dispatch:
 
 concurrency:
-  group: server-individual-tests-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
-  cancel-in-progress: false
+  group: server-individual-tests-lightmode-develop
+  cancel-in-progress: true
 
 permissions:
   contents: read
@@ -21,7 +21,7 @@ jobs:
     - id: set-matrix
       run: |
         # Use grep and find to get the list of test files
-        matrix=$(find . -path '*/doctype/*/test_*.py' | xargs grep -l 'def test_' | awk '{
+        matrix=$(find . -path '*/test_*.py' | xargs grep -l 'def test_' | sort | awk '{
             # Remove ./ prefix, file extension, and replace / with .
             gsub(/^\.\//, "", $0)
             gsub(/\.py$/, "", $0)
@@ -58,6 +58,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix: ${{fromJson(needs.discover.outputs.matrix)}}
+      max-parallel: 14
 
     name: Test
 
@@ -130,4 +131,13 @@ jobs:
           FRAPPE_BRANCH: ${{ github.event.inputs.branch }}
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-tests --app erpnext --module ${{ matrix.test }}'
+        run: |
+          site_name=$(echo "${{matrix.test}}" | sed -e 's/.*\.\(test_.*$\)/\1/')
+          echo "$site_name"
+          mkdir ~/frappe-bench/sites/$site_name
+          cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_mariadb.json" ~/frappe-bench/sites/$site_name/site_config.json
+          cd ~/frappe-bench/
+          bench --site $site_name reinstall --yes
+          bench --site $site_name set-config allow_tests true
+          bench --site $site_name run-tests --module ${{ matrix.test }} --lightmode
+

.github/workflows/server-tests-mariadb.yml

@@ -129,7 +129,7 @@ jobs:
           FRAPPE_BRANCH: ${{ github.event.client_payload.sha || github.event.inputs.branch }}
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }} --with-coverage'
+        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --lightmode --app erpnext --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }} --with-coverage'
         env:
           TYPE: server
 

erpnext/__init__.py

@@ -6,7 +6,7 @@ import frappe
 from frappe.model.document import Document
 from frappe.utils.user import is_website_user
 
-__version__ = "16.9.1"
+__version__ = "16.11.0"
 
 
 def get_default_company(user=None):

erpnext/accounts/deferred_revenue.py

@@ -524,7 +524,8 @@ def make_gl_entries(
 	if gl_entries:
 		try:
 			make_gl_entries(gl_entries, cancel=(doc.docstatus == 2), merge_entries=True)
-			frappe.db.commit()
+			if not frappe.in_test:
+				frappe.db.commit()
 		except Exception as e:
 			if frappe.in_test:
 				doc.log_error(f"Error while processing deferred accounting for Invoice {doc.name}")
@@ -606,7 +607,8 @@ def book_revenue_via_journal_entry(
 		if submit:
 			journal_entry.submit()
 
-		frappe.db.commit()
+		if not frappe.in_test:
+			frappe.db.commit()
 	except Exception:
 		frappe.db.rollback()
 		doc.log_error(f"Error while processing deferred accounting for Invoice {doc.name}")

erpnext/accounts/doctype/account/test_account.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.account.account import (
@@ -12,11 +11,10 @@ from erpnext.accounts.doctype.account.account import (
 	update_account_number,
 )
 from erpnext.stock import get_company_default_inventory_account, get_warehouse_account
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Company"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccount(IntegrationTestCase):
+class TestAccount(ERPNextTestSuite):
 	def test_rename_account(self):
 		if not frappe.db.exists("Account", "1210 - Debtors - _TC"):
 			acc = frappe.new_doc("Account")

erpnext/accounts/doctype/account/test_records.json

@@ -1,6 +0,0 @@
-[
-	{
-		"doctype": "Account",
-		"name": "_Test Account 1"
-	}
-]

erpnext/accounts/doctype/account_category/test_account_category.py

@@ -2,19 +2,3 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
-
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-
-
-class IntegrationTestAccountCategory(IntegrationTestCase):
-	"""
-	Integration tests for AccountCategory.
-	Use this class for testing interactions between multiple components.
-	"""
-
-	pass

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.py

@@ -2,8 +2,9 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
+
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccountClosingBalance(IntegrationTestCase):
+class TestAccountClosingBalance(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -103,10 +103,6 @@ class AccountingDimension(Document):
 		if not self.fieldname:
 			self.fieldname = scrub(self.label)
 
-	def on_update(self):
-		frappe.flags.accounting_dimensions = None
-		frappe.flags.accounting_dimensions_details = None
-
 
 def make_dimension_in_accounting_doctypes(doc, doclist=None):
 	if not doclist:
@@ -241,34 +237,26 @@ def get_doctypes_with_dimensions():
 	return frappe.get_hooks("accounting_dimension_doctypes")
 
 
-def get_accounting_dimensions(as_list=True, filters=None):
-	if not filters:
-		filters = {"disabled": 0}
-
-	if frappe.flags.accounting_dimensions is None:
-		frappe.flags.accounting_dimensions = frappe.get_all(
-			"Accounting Dimension",
-			fields=["label", "fieldname", "disabled", "document_type"],
-			filters=filters,
-		)
+def get_accounting_dimensions(as_list=True):
+	accounting_dimensions = frappe.get_all(
+		"Accounting Dimension",
+		fields=["label", "fieldname", "disabled", "document_type"],
+		filters={"disabled": 0},
+	)
 
 	if as_list:
-		return [d.fieldname for d in frappe.flags.accounting_dimensions]
+		return [d.fieldname for d in accounting_dimensions]
 	else:
-		return frappe.flags.accounting_dimensions
+		return accounting_dimensions
 
 
 def get_checks_for_pl_and_bs_accounts():
-	if frappe.flags.accounting_dimensions_details is None:
-		# nosemgrep
-		frappe.flags.accounting_dimensions_details = frappe.db.sql(
-			"""SELECT p.label, p.disabled, p.fieldname, c.default_dimension, c.company, c.mandatory_for_pl, c.mandatory_for_bs
+	return frappe.db.sql(
+		"""SELECT p.label, p.disabled, p.fieldname, c.default_dimension, c.company, c.mandatory_for_pl, c.mandatory_for_bs
 			FROM `tabAccounting Dimension`p ,`tabAccounting Dimension Detail` c
 			WHERE p.name = c.parent AND p.disabled = 0""",
-			as_dict=1,
-		)
-
-	return frappe.flags.accounting_dimensions_details
+		as_dict=1,
+	)
 
 
 def get_dimension_with_children(doctype, dimensions):

erpnext/accounts/doctype/accounting_dimension/test_accounting_dimension.py

@@ -3,15 +3,13 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Cost Center", "Location", "Warehouse", "Department"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccountingDimension(IntegrationTestCase):
+class TestAccountingDimension(ERPNextTestSuite):
 	def setUp(self):
 		create_dimension()
 
@@ -80,11 +78,6 @@ class TestAccountingDimension(IntegrationTestCase):
 		si.save()
 		self.assertRaises(frappe.ValidationError, si.submit)
 
-	def tearDown(self):
-		disable_dimension()
-		frappe.flags.accounting_dimensions_details = None
-		frappe.flags.dimension_filter_map = None
-
 
 def create_dimension():
 	frappe.set_user("Administrator")

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.py

@@ -69,37 +69,34 @@ class AccountingDimensionFilter(Document):
 
 
 def get_dimension_filter_map():
-	if not frappe.flags.get("dimension_filter_map"):
-		filters = frappe.db.sql(
-			"""
-			SELECT
-				a.applicable_on_account, d.dimension_value, p.accounting_dimension,
-				p.allow_or_restrict, p.fieldname, a.is_mandatory
-			FROM
-				`tabApplicable On Account` a,
-				`tabAccounting Dimension Filter` p
-			LEFT JOIN `tabAllowed Dimension` d ON d.parent = p.name
-			WHERE
-				p.name = a.parent
-				AND p.disabled = 0
-		""",
-			as_dict=1,
+	filters = frappe.db.sql(
+		"""
+		SELECT
+			a.applicable_on_account, d.dimension_value, p.accounting_dimension,
+			p.allow_or_restrict, p.fieldname, a.is_mandatory
+		FROM
+			`tabApplicable On Account` a,
+			`tabAccounting Dimension Filter` p
+		LEFT JOIN `tabAllowed Dimension` d ON d.parent = p.name
+		WHERE
+			p.name = a.parent
+			AND p.disabled = 0
+	""",
+		as_dict=1,
+	)
+
+	dimension_filter_map = {}
+
+	for f in filters:
+		build_map(
+			dimension_filter_map,
+			f.fieldname,
+			f.applicable_on_account,
+			f.dimension_value,
+			f.allow_or_restrict,
+			f.is_mandatory,
 		)
-
-		dimension_filter_map = {}
-
-		for f in filters:
-			build_map(
-				dimension_filter_map,
-				f.fieldname,
-				f.applicable_on_account,
-				f.dimension_value,
-				f.allow_or_restrict,
-				f.is_mandatory,
-			)
-		frappe.flags.dimension_filter_map = dimension_filter_map
-
-	return frappe.flags.dimension_filter_map
+	return dimension_filter_map
 
 
 def build_map(map_object, dimension, account, filter_value, allow_or_restrict, is_mandatory):

erpnext/accounts/doctype/accounting_dimension_filter/test_accounting_dimension_filter.py

@@ -11,11 +11,10 @@ from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension imp
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.exceptions import InvalidAccountDimensionError, MandatoryAccountDimensionError
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Location", "Cost Center", "Department"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccountingDimensionFilter(unittest.TestCase):
+class TestAccountingDimensionFilter(ERPNextTestSuite):
 	def setUp(self):
 		create_dimension()
 		create_accounting_dimension_filter()
@@ -44,17 +43,6 @@ class TestAccountingDimensionFilter(unittest.TestCase):
 		self.assertRaises(MandatoryAccountDimensionError, si.submit)
 		self.invoice_list.append(si)
 
-	def tearDown(self):
-		disable_dimension_filter()
-		disable_dimension()
-		frappe.flags.accounting_dimensions_details = None
-		frappe.flags.dimension_filter_map = None
-
-		for si in self.invoice_list:
-			si.load_from_db()
-			if si.docstatus == 1:
-				si.cancel()
-
 
 def create_accounting_dimension_filter():
 	if not frappe.db.get_value("Accounting Dimension Filter", {"accounting_dimension": "Cost Center"}):

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_months, nowdate
 
 from erpnext.accounts.doctype.accounting_period.accounting_period import (
@@ -11,11 +10,10 @@ from erpnext.accounts.doctype.accounting_period.accounting_period import (
 	OverlapError,
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccountingPeriod(IntegrationTestCase):
+class TestAccountingPeriod(ERPNextTestSuite):
 	def test_overlap(self):
 		ap1 = create_accounting_period(
 			start_date="2018-04-01", end_date="2018-06-30", company="Wind Power LLC"
@@ -90,10 +88,6 @@ class TestAccountingPeriod(IntegrationTestCase):
 		doc.submit()  # Should not raise
 		self.assertEqual(doc.docstatus, 1)
 
-	def tearDown(self):
-		for d in frappe.get_all("Accounting Period"):
-			frappe.delete_doc("Accounting Period", d.name)
-
 
 def create_accounting_period(**args):
 	args = frappe._dict(args)

erpnext/accounts/doctype/accounts_settings/test_accounts_settings.py

@@ -1,17 +1,11 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
+
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAccountsSettings(IntegrationTestCase):
-	def tearDown(self):
-		# Just in case `save` method succeeds, we need to take things back to default so that other tests
-		# don't break
-		cur_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
-		cur_settings.allow_stale = 1
-		cur_settings.save()
-
+class TestAccountsSettings(ERPNextTestSuite):
 	def test_stale_days(self):
 		cur_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
 		cur_settings.allow_stale = 0

erpnext/accounts/doctype/advance_payment_ledger_entry/test_advance_payment_ledger_entry.py

@@ -2,7 +2,6 @@
 # See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate, today
 
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
@@ -10,14 +9,13 @@ from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 
-# On IntegrationTestCase, the doctype test records and all
+# On ERPNextTestSuite, the doctype test records and all
 # link-field test record depdendencies are recursively loaded
 # Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestAdvancePaymentLedgerEntry(AccountsTestMixin, IntegrationTestCase):
+class TestAdvancePaymentLedgerEntry(AccountsTestMixin, ERPNextTestSuite):
 	"""
 	Integration tests for AdvancePaymentLedgerEntry.
 	Use this class for testing interactions between multiple components.
@@ -30,9 +28,6 @@ class TestAdvancePaymentLedgerEntry(AccountsTestMixin, IntegrationTestCase):
 		self.create_item()
 		self.clear_old_entries()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def create_sales_order(self, qty=1, rate=100, currency="INR", do_not_submit=False):
 		"""
 		Helper method

erpnext/accounts/doctype/bank/test_bank.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBank(IntegrationTestCase):
+class TestBank(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bank_account/test_bank_account.py

@@ -2,10 +2,8 @@
 # See license.txt
 import unittest
 
-import frappe
-from frappe import ValidationError
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankAccount(IntegrationTestCase):
+class TestBankAccount(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bank_account_subtype/test_bank_account_subtype.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankAccountSubtype(IntegrationTestCase):
+class TestBankAccountSubtype(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bank_account_type/test_bank_account_type.py

@@ -3,8 +3,8 @@
 # import frappe
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankAccountType(IntegrationTestCase):
+class TestBankAccountType(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -5,8 +5,10 @@
 import frappe
 from frappe import _, msgprint
 from frappe.model.document import Document
+from frappe.query_builder import Case
 from frappe.query_builder.custom import ConstantColumn
-from frappe.utils import cint, flt, fmt_money, get_link_to_form, getdate
+from frappe.query_builder.functions import Coalesce, Sum
+from frappe.utils import cint, flt, fmt_money, getdate
 from pypika import Order
 
 import erpnext
@@ -182,65 +184,162 @@ def get_payment_entries_for_bank_clearance(
 ):
 	entries = []
 
-	condition = ""
-	pe_condition = ""
+	journal_entry = frappe.qb.DocType("Journal Entry")
+	journal_entry_account = frappe.qb.DocType("Journal Entry Account")
+
+	journal_entry_query = (
+		frappe.qb.from_(journal_entry_account)
+		.inner_join(journal_entry)
+		.on(journal_entry_account.parent == journal_entry.name)
+		.select(
+			ConstantColumn("Journal Entry").as_("payment_document"),
+			journal_entry.name.as_("payment_entry"),
+			journal_entry.cheque_no.as_("cheque_number"),
+			journal_entry.cheque_date,
+			Sum(journal_entry_account.debit_in_account_currency).as_("debit"),
+			Sum(journal_entry_account.credit_in_account_currency).as_("credit"),
+			journal_entry.posting_date,
+			journal_entry_account.against_account,
+			journal_entry.clearance_date,
+			journal_entry_account.account_currency,
+		)
+		.where(
+			(journal_entry_account.account == account)
+			& (journal_entry.docstatus == 1)
+			& (journal_entry.posting_date >= from_date)
+			& (journal_entry.posting_date <= to_date)
+			& (journal_entry.is_opening == "No")
+		)
+	)
+
 	if not include_reconciled_entries:
-		condition = "and (clearance_date IS NULL or clearance_date='0000-00-00')"
-		pe_condition = "and (pe.clearance_date IS NULL or pe.clearance_date='0000-00-00')"
+		journal_entry_query = journal_entry_query.where(
+			(journal_entry.clearance_date.isnull()) | (journal_entry.clearance_date == "0000-00-00")
+		)
 
-	journal_entries = frappe.db.sql(
-		f"""
-			select
-				"Journal Entry" as payment_document, t1.name as payment_entry,
-				t1.cheque_no as cheque_number, t1.cheque_date,
-				sum(t2.debit_in_account_currency) as debit, sum(t2.credit_in_account_currency) as credit,
-				t1.posting_date, t2.against_account, t1.clearance_date, t2.account_currency
-			from
-				`tabJournal Entry` t1, `tabJournal Entry Account` t2
-			where
-				t2.parent = t1.name and t2.account = %(account)s and t1.docstatus=1
-				and t1.posting_date >= %(from)s and t1.posting_date <= %(to)s
-				and ifnull(t1.is_opening, 'No') = 'No' {condition}
-			group by t2.account, t1.name
-			order by t1.posting_date ASC, t1.name DESC
-		""",
-		{"account": account, "from": from_date, "to": to_date},
-		as_dict=1,
+	journal_entries = (
+		journal_entry_query.groupby(journal_entry_account.account, journal_entry.name)
+		.orderby(journal_entry.posting_date)
+		.orderby(journal_entry.name, order=Order.desc)
+	).run(as_dict=True)
+
+	pe = frappe.qb.DocType("Payment Entry")
+	company = frappe.qb.DocType("Company")
+	payment_entry_query = (
+		frappe.qb.from_(pe)
+		.join(company)
+		.on(pe.company == company.name)
+		.select(
+			ConstantColumn("Payment Entry").as_("payment_document"),
+			pe.name.as_("payment_entry"),
+			pe.reference_no.as_("cheque_number"),
+			pe.reference_date.as_("cheque_date"),
+			(
+				Case()
+				.when(
+					pe.paid_from == account,
+					(
+						pe.paid_amount
+						+ (
+							Case()
+							.when(
+								(pe.payment_type == "Pay")
+								& (company.default_currency == pe.paid_from_account_currency),
+								pe.base_total_taxes_and_charges,
+							)
+							.else_(pe.total_taxes_and_charges)
+						)
+					),
+				)
+				.else_(0)
+			).as_("credit"),
+			(
+				Case()
+				.when(pe.paid_from == account, 0)
+				.else_(
+					pe.received_amount
+					+ (
+						Case()
+						.when(
+							company.default_currency == pe.paid_to_account_currency,
+							pe.base_total_taxes_and_charges,
+						)
+						.else_(pe.total_taxes_and_charges)
+					)
+				)
+			).as_("debit"),
+			pe.posting_date,
+			Coalesce(pe.party, Case().when(pe.paid_from == account, pe.paid_to).else_(pe.paid_from)).as_(
+				"against_account"
+			),
+			pe.clearance_date,
+			(
+				Case()
+				.when(pe.paid_to == account, pe.paid_to_account_currency)
+				.else_(pe.paid_from_account_currency)
+			).as_("account_currency"),
+		)
+		.where(
+			((pe.paid_from == account) | (pe.paid_to == account))
+			& (pe.docstatus == 1)
+			& (pe.posting_date >= from_date)
+			& (pe.posting_date <= to_date)
+		)
 	)
 
-	payment_entries = frappe.db.sql(
-		f"""
-			select
-				"Payment Entry" as payment_document, pe.name as payment_entry,
-				pe.reference_no as cheque_number, pe.reference_date as cheque_date,
-				if(pe.paid_from=%(account)s, pe.paid_amount + if(pe.payment_type = 'Pay' and c.default_currency = pe.paid_from_account_currency, pe.base_total_taxes_and_charges, pe.total_taxes_and_charges) , 0) as credit,
-				if(pe.paid_from=%(account)s, 0, pe.received_amount + pe.total_taxes_and_charges) as debit,
-				pe.posting_date, ifnull(pe.party,if(pe.paid_from=%(account)s,pe.paid_to,pe.paid_from)) as against_account, pe.clearance_date,
-				if(pe.paid_to=%(account)s, pe.paid_to_account_currency, pe.paid_from_account_currency) as account_currency
-			from `tabPayment Entry` as pe
-			join `tabCompany` c on c.name = pe.company
-			where
-				(pe.paid_from=%(account)s or pe.paid_to=%(account)s) and pe.docstatus=1
-				and pe.posting_date >= %(from)s and pe.posting_date <= %(to)s
-				{pe_condition}
-			order by
-				pe.posting_date ASC, pe.name DESC
-		""",
-		{
-			"account": account,
-			"from": from_date,
-			"to": to_date,
-		},
-		as_dict=1,
+	if not include_reconciled_entries:
+		payment_entry_query = payment_entry_query.where(
+			(pe.clearance_date.isnull()) | (pe.clearance_date == "0000-00-00")
+		)
+
+	payment_entries = (payment_entry_query.orderby(pe.posting_date).orderby(pe.name, order=Order.desc)).run(
+		as_dict=True
 	)
 
-	pos_sales_invoices, pos_purchase_invoices = [], []
+	acc = frappe.qb.DocType("Account")
+
+	pi = frappe.qb.DocType("Purchase Invoice")
+
+	paid_purchase_invoices_query = (
+		frappe.qb.from_(pi)
+		.inner_join(acc)
+		.on(pi.cash_bank_account == acc.name)
+		.select(
+			ConstantColumn("Purchase Invoice").as_("payment_document"),
+			pi.name.as_("payment_entry"),
+			pi.paid_amount.as_("credit"),
+			pi.posting_date,
+			pi.supplier.as_("against_account"),
+			pi.bill_no.as_("cheque_number"),
+			pi.clearance_date,
+			acc.account_currency,
+			ConstantColumn(0).as_("debit"),
+		)
+		.where(
+			(pi.docstatus == 1)
+			& (pi.is_paid == 1)
+			& (pi.cash_bank_account == account)
+			& (pi.posting_date >= from_date)
+			& (pi.posting_date <= to_date)
+		)
+	)
+
+	if not include_reconciled_entries:
+		paid_purchase_invoices_query = paid_purchase_invoices_query.where(
+			(pi.clearance_date.isnull()) | (pi.clearance_date == "0000-00-00")
+		)
+
+	paid_purchase_invoices = (
+		paid_purchase_invoices_query.orderby(pi.posting_date).orderby(pi.name, order=Order.desc)
+	).run(as_dict=True)
+
+	pos_sales_invoices = []
+
 	if include_pos_transactions:
 		si_payment = frappe.qb.DocType("Sales Invoice Payment")
 		si = frappe.qb.DocType("Sales Invoice")
-		acc = frappe.qb.DocType("Account")
 
-		pos_sales_invoices = (
+		pos_sales_invoices_query = (
 			frappe.qb.from_(si_payment)
 			.inner_join(si)
 			.on(si_payment.parent == si.name)
@@ -263,38 +362,22 @@ def get_payment_entries_for_bank_clearance(
 				& (si.posting_date >= from_date)
 				& (si.posting_date <= to_date)
 			)
-			.orderby(si.posting_date)
-			.orderby(si.name, order=Order.desc)
-		).run(as_dict=True)
+		)
 
-		pi = frappe.qb.DocType("Purchase Invoice")
+		if not include_reconciled_entries:
+			pos_sales_invoices_query = pos_sales_invoices_query.where(
+				(si_payment.clearance_date.isnull()) | (si_payment.clearance_date == "0000-00-00")
+			)
 
-		pos_purchase_invoices = (
-			frappe.qb.from_(pi)
-			.inner_join(acc)
-			.on(pi.cash_bank_account == acc.name)
-			.select(
-				ConstantColumn("Purchase Invoice").as_("payment_document"),
-				pi.name.as_("payment_entry"),
-				pi.paid_amount.as_("credit"),
-				pi.posting_date,
-				pi.supplier.as_("against_account"),
-				pi.clearance_date,
-				acc.account_currency,
-				ConstantColumn(0).as_("debit"),
-			)
-			.where(
-				(pi.docstatus == 1)
-				& (pi.cash_bank_account == account)
-				& (pi.posting_date >= from_date)
-				& (pi.posting_date <= to_date)
-			)
-			.orderby(pi.posting_date)
-			.orderby(pi.name, order=Order.desc)
+		pos_sales_invoices = (
+			pos_sales_invoices_query.orderby(si.posting_date).orderby(si.name, order=Order.desc)
 		).run(as_dict=True)
 
 	entries = (
-		list(payment_entries) + list(journal_entries) + list(pos_sales_invoices) + list(pos_purchase_invoices)
+		list(payment_entries)
+		+ list(journal_entries)
+		+ list(pos_sales_invoices)
+		+ list(paid_purchase_invoices)
 	)
 
 	return entries

erpnext/accounts/doctype/bank_clearance/test_bank_clearance.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_months, getdate
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
@@ -15,13 +14,12 @@ from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.stock.doctype.item.test_item import create_item
 from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse
-from erpnext.tests.utils import if_lending_app_installed, if_lending_app_not_installed
+from erpnext.tests.utils import ERPNextTestSuite, if_lending_app_installed, if_lending_app_not_installed
 
 
-class TestBankClearance(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
+class TestBankClearance(ERPNextTestSuite):
+	def setUp(self):
+		frappe.clear_cache()
 		create_warehouse(
 			warehouse_name="_Test Warehouse",
 			properties={"parent_warehouse": "All Warehouses - _TC"},

erpnext/accounts/doctype/bank_guarantee/test_bank_guarantee.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankGuarantee(IntegrationTestCase):
+class TestBankGuarantee(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -4,7 +4,6 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
@@ -13,9 +12,10 @@ from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool
 )
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankReconciliationTool(AccountsTestMixin, IntegrationTestCase):
+class TestBankReconciliationTool(AccountsTestMixin, ERPNextTestSuite):
 	def setUp(self):
 		self.create_company()
 		self.create_customer()
@@ -24,9 +24,6 @@ class TestBankReconciliationTool(AccountsTestMixin, IntegrationTestCase):
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def create_bank_account(self):
 		bank = frappe.get_doc(
 			{
@@ -43,6 +40,7 @@ class TestBankReconciliationTool(AccountsTestMixin, IntegrationTestCase):
 					"bank": bank.name,
 					"is_company_account": True,
 					"account": self.bank,  # account from Chart of Accounts
+					"company": self.company,
 				}
 			)
 			.insert()

erpnext/accounts/doctype/bank_statement_import/test_bank_statement_import.py

@@ -1,15 +1,14 @@
 # Copyright (c) 2020, Frappe Technologies and Contributors
 # See license.txt
 
-import unittest
-
 from erpnext.accounts.doctype.bank_statement_import.bank_statement_import import (
 	is_mt940_format,
 	preprocess_mt940_content,
 )
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestBankStatementImport(unittest.TestCase):
+class TestBankStatementImport(ERPNextTestSuite):
 	"""Unit tests for Bank Statement Import functions"""
 
 	def test_preprocess_mt940_content_with_long_statement_number(self):

erpnext/accounts/doctype/bank_transaction/test_auto_match_party.py

@@ -2,27 +2,20 @@
 # License: GNU General Public License v3. See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import create_bank_account
+from erpnext.tests.utils import ERPNextTestSuite
 
 IBAN_1 = "DE02000000003716541159"
 IBAN_2 = "DE02500105170137075030"
 
 
-class TestAutoMatchParty(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
+class TestAutoMatchParty(ERPNextTestSuite):
+	def setUp(self):
 		create_bank_account()
 		frappe.db.set_single_value("Accounts Settings", "enable_party_matching", 1)
 		frappe.db.set_single_value("Accounts Settings", "enable_fuzzy_matching", 1)
-		return super().setUpClass()
-
-	@classmethod
-	def tearDownClass(cls):
-		frappe.db.set_single_value("Accounts Settings", "enable_party_matching", 0)
-		frappe.db.set_single_value("Accounts Settings", "enable_fuzzy_matching", 0)
 
 	def test_match_by_account_number(self):
 		create_supplier_for_match(account_no=IBAN_1[11:])

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -6,7 +6,6 @@ import json
 import frappe
 from frappe import utils
 from frappe.model.docstatus import DocStatus
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool import (
 	get_linked_payments,
@@ -19,12 +18,10 @@ from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_paymen
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
-from erpnext.tests.utils import if_lending_app_installed
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item", "Cost Center"]
+from erpnext.tests.utils import ERPNextTestSuite, if_lending_app_installed
 
 
-class TestBankTransaction(IntegrationTestCase):
+class TestBankTransaction(ERPNextTestSuite):
 	def setUp(self):
 		make_pos_profile()
 

erpnext/accounts/doctype/bisect_accounting_statements/test_bisect_accounting_statements.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestBisectAccountingStatements(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestBisectAccountingStatements(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/bisect_nodes/test_bisect_nodes.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestBisectNodes(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestBisectNodes(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/budget/test_budget.py

@@ -19,12 +19,6 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestBudget(ERPNextTestSuite):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		cls.make_monthly_distribution()
-		cls.make_projects()
-
 	def setUp(self):
 		frappe.db.set_single_value("Accounts Settings", "use_legacy_budget_controller", False)
 		self.company = "_Test Company"

erpnext/accounts/doctype/cashier_closing/test_cashier_closing.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestCashierClosing(IntegrationTestCase):
+class TestCashierClosing(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/chart_of_accounts_importer/test_chart_of_accounts_importer.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestChartofAccountsImporter(IntegrationTestCase):
+class TestChartofAccountsImporter(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/cheque_print_template/test_cheque_print_template.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestChequePrintTemplate(IntegrationTestCase):
+class TestChequePrintTemplate(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/cost_center/test_cost_center.py

@@ -3,10 +3,11 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
+
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestCostCenter(IntegrationTestCase):
+class TestCostCenter(ERPNextTestSuite):
 	def test_cost_center_creation_against_child_node(self):
 		cost_center = frappe.get_doc(
 			{

erpnext/accounts/doctype/cost_center/test_records.json

@@ -1,23 +0,0 @@
-[
- {
-  "company": "_Test Company",
-  "cost_center_name": "_Test Cost Center",
-  "doctype": "Cost Center",
-  "is_group": 0,
-  "parent_cost_center": "_Test Company - _TC"
- },
- {
-  "company": "_Test Company",
-  "cost_center_name": "_Test Cost Center 2",
-  "doctype": "Cost Center",
-  "is_group": 0,
-  "parent_cost_center": "_Test Company - _TC"
- },
- {
-  "company": "_Test Company",
-  "cost_center_name": "_Test Write Off Cost Center",
-  "doctype": "Cost Center",
-  "is_group": 0,
-  "parent_cost_center": "_Test Company - _TC"
- }
-]

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

@@ -4,7 +4,6 @@ import unittest
 
 import frappe
 from frappe.query_builder.functions import Sum
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.cost_center.test_cost_center import create_cost_center
@@ -16,9 +15,10 @@ from erpnext.accounts.doctype.cost_center_allocation.cost_center_allocation impo
 	WrongPercentageAllocation,
 )
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestCostCenterAllocation(IntegrationTestCase):
+class TestCostCenterAllocation(ERPNextTestSuite):
 	def setUp(self):
 		cost_centers = [
 			"Main Cost Center 1",
@@ -191,7 +191,7 @@ class TestCostCenterAllocation(IntegrationTestCase):
 		coa2.cancel()
 		jv.cancel()
 
-	@IntegrationTestCase.change_settings("System Settings", {"rounding_method": "Commercial Rounding"})
+	@ERPNextTestSuite.change_settings("System Settings", {"rounding_method": "Commercial Rounding"})
 	def test_debit_credit_on_cost_center_allocation_for_commercial_rounding(self):
 		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 

erpnext/accounts/doctype/coupon_code/test_coupon_code.py

@@ -3,11 +3,9 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
 def test_create_test_data():
@@ -88,6 +86,7 @@ def test_create_test_data():
 				"partner_name": "_Test Coupon Partner",
 				"commission_rate": 2,
 				"referral_code": "COPART",
+				"territory": "All Territories",
 			}
 		)
 		sales_partner.insert()
@@ -110,13 +109,10 @@ def test_create_test_data():
 		coupon_code.insert()
 
 
-class TestCouponCode(IntegrationTestCase):
+class TestCouponCode(ERPNextTestSuite):
 	def setUp(self):
 		test_create_test_data()
 
-	def tearDown(self):
-		frappe.set_user("Administrator")
-
 	def test_sales_order_with_coupon_code(self):
 		frappe.db.set_value("Coupon Code", "SAVE30", "used", 0)
 

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -101,11 +101,11 @@
    "label": "Use HTTP Protocol"
   }
  ],
- "hide_toolbar": 1,
+ "hide_toolbar": 0,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-01-02 18:19:02.873815",
+ "modified": "2026-03-16 13:28:21.075743",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",

erpnext/accounts/doctype/currency_exchange_settings/test_currency_exchange_settings.py

@@ -3,8 +3,8 @@
 # import frappe
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestCurrencyExchangeSettings(IntegrationTestCase):
+class TestCurrencyExchangeSettings(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -4,37 +4,20 @@ import json
 
 import frappe
 from frappe.model import mapper
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, nowdate, today
 
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
-from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import (
-	unlink_payment_on_cancel_of_invoice,
-)
 from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
 	create_dunning as create_dunning_from_sales_invoice,
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
 	create_sales_invoice_against_cost_center,
 )
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Company", "Cost Center"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestDunning(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		create_dunning_type("First Notice", fee=0.0, interest=0.0, is_default=1)
-		create_dunning_type("Second Notice", fee=10.0, interest=10.0, is_default=0)
-		unlink_payment_on_cancel_of_invoice()
-
-	@classmethod
-	def tearDownClass(cls):
-		unlink_payment_on_cancel_of_invoice(0)
-		super().tearDownClass()
-
+class TestDunning(ERPNextTestSuite):
 	def test_dunning_without_fees(self):
 		dunning = create_dunning(overdue_days=20)
 

erpnext/accounts/doctype/dunning_type/test_dunning_type.py

@@ -3,8 +3,8 @@
 # import frappe
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestDunningType(IntegrationTestCase):
+class TestDunningType(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/dunning_type/test_records.json

@@ -1,36 +0,0 @@
-[
-    {
-        "doctype": "Dunning Type",
-        "dunning_type": "_Test First Notice",
-        "company": "_Test Company",
-        "is_default": 1,
-        "dunning_fee": 0.0,
-        "rate_of_interest": 0.0,
-        "dunning_letter_text": [
-            {
-                "language": "en",
-                "body_text": "We have still not received payment for our invoice",
-                "closing_text": "We kindly request that you pay the outstanding amount immediately, including interest and late fees."
-            }
-        ],
-        "income_account": "Sales - _TC",
-        "cost_center": "_Test Cost Center - _TC"
-    },
-    {
-        "doctype": "Dunning Type",
-        "dunning_type": "_Test Second Notice",
-        "company": "_Test Company",
-        "is_default": 0,
-        "dunning_fee": 10.0,
-        "rate_of_interest": 10.0,
-        "dunning_letter_text": [
-            {
-                "language": "en",
-                "body_text": "We have still not received payment for our invoice",
-                "closing_text": "We kindly request that you pay the outstanding amount immediately, including interest and late fees."
-            }
-        ],
-        "income_account": "Sales - _TC",
-        "cost_center": "_Test Cost Center - _TC"
-    }
-]

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -5,15 +5,15 @@
 import frappe
 from frappe.query_builder import functions
 from frappe.query_builder.utils import DocType
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, flt, today
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
+class TestExchangeRateRevaluation(AccountsTestMixin, ERPNextTestSuite):
 	def setUp(self):
 		self.create_company()
 		self.create_usd_receivable_account()
@@ -22,14 +22,13 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.clear_old_entries()
 		self.set_system_and_company_settings()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def set_system_and_company_settings(self):
 		# set number and currency precision
 		system_settings = frappe.get_doc("System Settings")
 		system_settings.float_precision = 2
 		system_settings.currency_precision = 2
+		system_settings.language = "en"
+		system_settings.time_zone = "Asia/Kolkata"
 		system_settings.save()
 
 		# Using Exchange Gain/Loss account for unrealized as well.
@@ -37,7 +36,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
 		company_doc.save()
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
 	)
@@ -91,7 +90,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		)[0]
 		self.assertEqual(acc_balance.balance, 8500.0)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
 	)
@@ -164,7 +163,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.assertEqual(acc_balance.balance, 0.0)
 		self.assertEqual(acc_balance.balance_in_account_currency, 0.0)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
 	)
@@ -259,7 +258,7 @@ class TestExchangeRateRevaluation(AccountsTestMixin, IntegrationTestCase):
 		self.assertEqual(flt(acc_balance.balance, precision), 0.0)
 		self.assertEqual(flt(acc_balance.balance_in_account_currency, precision), 0.0)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
 	)

erpnext/accounts/doctype/finance_book/test_finance_book.py

@@ -3,12 +3,12 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestFinanceBook(IntegrationTestCase):
+class TestFinanceBook(ERPNextTestSuite):
 	def test_finance_book(self):
 		finance_book = create_finance_book()
 

erpnext/accounts/doctype/financial_report_template/test_financial_report_engine.py

@@ -19,12 +19,6 @@ from erpnext.accounts.doctype.financial_report_template.test_financial_report_te
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.utils import get_currency_precision, get_fiscal_year
 
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-
 
 class TestDependencyResolver(FinancialReportTemplateTestCase):
 	"""Test cases for DependencyResolver class"""

erpnext/accounts/doctype/financial_report_template/test_financial_report_template.py

@@ -2,29 +2,16 @@
 # For license information, please see license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase
-from frappe.tests.utils import make_test_records
 
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestFinancialReportTemplate(IntegrationTestCase):
-	pass
-
-
-class FinancialReportTemplateTestCase(IntegrationTestCase):
+class FinancialReportTemplateTestCase(ERPNextTestSuite):
 	"""Utility class with common setup and helper methods for all test classes"""
 
-	@classmethod
-	def setUpClass(cls):
+	def setUp(self):
 		"""Set up test data"""
-		make_test_records("Company")
-		make_test_records("Fiscal Year")
-		cls.create_test_template()
+		self.create_test_template()
 
 	@classmethod
 	def create_test_template(cls):

erpnext/accounts/doctype/fiscal_year/test_fiscal_year.py

@@ -3,13 +3,12 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import now_datetime
 
-IGNORE_TEST_RECORD_DEPENDENCIES = ["Company"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestFiscalYear(IntegrationTestCase):
+class TestFiscalYear(ERPNextTestSuite):
 	def test_extra_year(self):
 		if frappe.db.exists("Fiscal Year", "_Test Fiscal Year 2000"):
 			frappe.delete_doc("Fiscal Year", "_Test Fiscal Year 2000")

erpnext/accounts/doctype/gl_entry/test_gl_entry.py

@@ -4,13 +4,13 @@ import unittest
 
 import frappe
 from frappe.model.naming import parse_naming_series
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.gl_entry.gl_entry import rename_gle_sle_docs
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestGLEntry(IntegrationTestCase):
+class TestGLEntry(ERPNextTestSuite):
 	def test_round_off_entry(self):
 		frappe.db.set_value("Company", "_Test Company", "round_off_account", "_Test Write Off - _TC")
 		frappe.db.set_value("Company", "_Test Company", "round_off_cost_center", "_Test Cost Center - _TC")

erpnext/accounts/doctype/invoice_discounting/test_invoice_discounting.py

@@ -3,16 +3,16 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import create_account
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_against_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import get_gl_entries
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestInvoiceDiscounting(IntegrationTestCase):
+class TestInvoiceDiscounting(ERPNextTestSuite):
 	def setUp(self):
 		self.ar_credit = create_account(
 			account_name="_Test Accounts Receivable Credit",

erpnext/accounts/doctype/item_tax_template/test_item_tax_template.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestItemTaxTemplate(IntegrationTestCase):
+class TestItemTaxTemplate(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/item_tax_template/test_records.json

@@ -1,79 +0,0 @@
-[
- {
-  "doctype": "Item Tax Template",
-  "title": "_Test Account Excise Duty @ 10",
-  "company": "_Test Company",
-  "taxes": [
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 10,
-    "tax_type": "_Test Account Excise Duty - _TC"
-   }
-  ]
- },
- {
-  "doctype": "Item Tax Template",
-  "title": "_Test Account Excise Duty @ 12",
-  "company": "_Test Company",
-  "taxes": [
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 12,
-    "tax_type": "_Test Account Excise Duty - _TC"
-   }
-  ]
- },
- {
-  "doctype": "Item Tax Template",
-  "title": "_Test Account Excise Duty @ 15",
-  "company": "_Test Company",
-  "taxes": [
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 15,
-    "tax_type": "_Test Account Excise Duty - _TC"
-   }
-  ]
- },
- {
-  "doctype": "Item Tax Template",
-  "title": "_Test Account Excise Duty @ 20",
-  "company": "_Test Company",
-  "taxes": [
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 20,
-    "tax_type": "_Test Account Excise Duty - _TC"
-   }
-  ]
- },
- {
-  "doctype": "Item Tax Template",
-  "title": "_Test Item Tax Template 1",
-  "company": "_Test Company",
-  "taxes": [
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 5,
-    "tax_type": "_Test Account Excise Duty - _TC"
-   },
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 10,
-    "tax_type": "_Test Account Education Cess - _TC"
-   },
-   {
-    "doctype": "Item Tax Template Detail",
-    "parentfield": "taxes",
-    "tax_rate": 15,
-    "tax_type": "_Test Account S&H Education Cess - _TC"
-   }
-  ]
- }
-]

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -293,6 +293,8 @@ class JournalEntry(AccountsController):
 
 		# References for this Journal are removed on the `on_cancel` event in accounts_controller
 		super().on_cancel()
+
+		from_doc_events = getattr(self, "ignore_linked_doctypes", ())
 		self.ignore_linked_doctypes = (
 			"GL Entry",
 			"Stock Ledger Entry",
@@ -306,6 +308,10 @@ class JournalEntry(AccountsController):
 			"Advance Payment Ledger Entry",
 			"Tax Withholding Entry",
 		)
+
+		if from_doc_events and from_doc_events != self.ignore_linked_doctypes:
+			self.ignore_linked_doctypes = self.ignore_linked_doctypes + from_doc_events
+
 		self.make_gl_entries(1)
 		JournalTaxWithholding(self).on_cancel()
 		self.unlink_advance_entry_reference()

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -2,19 +2,20 @@
 # License: GNU General Public License v3. See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import get_inventory_account
 from erpnext.accounts.doctype.journal_entry.journal_entry import StockAccountInvalidTransaction
 from erpnext.exceptions import InvalidAccountCurrency
 from erpnext.selling.doctype.customer.test_customer import make_customer, set_credit_limit
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestJournalEntry(IntegrationTestCase):
-	@IntegrationTestCase.change_settings(
-		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
-	)
+class TestJournalEntry(ERPNextTestSuite):
+	def setUp(self):
+		self.load_test_records("Journal Entry")
+
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_journal_entry_with_against_jv(self):
 		jv_invoice = frappe.copy_doc(self.globalTestRecords["Journal Entry"][2])
 		base_jv = frappe.copy_doc(self.globalTestRecords["Journal Entry"][0])
@@ -149,7 +150,6 @@ class TestJournalEntry(IntegrationTestCase):
 
 		if account_bal == stock_bal:
 			self.assertRaises(StockAccountInvalidTransaction, jv.save)
-			frappe.db.rollback()
 		else:
 			jv.submit()
 			jv.cancel()

erpnext/accounts/doctype/journal_entry_template/test_journal_entry_template.py

@@ -3,8 +3,8 @@
 # import frappe
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestJournalEntryTemplate(IntegrationTestCase):
+class TestJournalEntryTemplate(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/ledger_health/test_ledger_health.py

@@ -3,23 +3,20 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.accounts.utils import run_ledger_health_checks
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestLedgerHealth(AccountsTestMixin, IntegrationTestCase):
+class TestLedgerHealth(AccountsTestMixin, ERPNextTestSuite):
 	def setUp(self):
 		self.create_company()
 		self.create_customer()
 		self.configure_monitoring_tool()
 		self.clear_old_entries()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def configure_monitoring_tool(self):
 		monitor_settings = frappe.get_doc("Ledger Health Monitor")
 		monitor_settings.enable_health_monitor = True

erpnext/accounts/doctype/ledger_health_monitor/test_ledger_health_monitor.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestLedgerHealthMonitor(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestLedgerHealthMonitor(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/ledger_merge/test_ledger_merge.py

@@ -3,12 +3,12 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.ledger_merge.ledger_merge import start_merge
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestLedgerMerge(IntegrationTestCase):
+class TestLedgerMerge(ERPNextTestSuite):
 	def test_merge_success(self):
 		if not frappe.db.exists("Account", "Indirect Expenses - _TC"):
 			acc = frappe.new_doc("Account")
@@ -101,16 +101,3 @@ class TestLedgerMerge(IntegrationTestCase):
 
 		self.assertFalse(frappe.db.exists("Account", "Indirect Test Income - _TC"))
 		self.assertTrue(frappe.db.exists("Account", "Administrative Test Income - _TC"))
-
-	def tearDown(self):
-		for entry in frappe.db.get_all("Ledger Merge"):
-			frappe.delete_doc("Ledger Merge", entry.name)
-
-		test_accounts = [
-			"Indirect Test Expenses - _TC",
-			"Administrative Test Expenses - _TC",
-			"Indirect Test Income - _TC",
-			"Administrative Test Income - _TC",
-		]
-		for account in test_accounts:
-			frappe.delete_doc_if_exists("Account", account)

erpnext/accounts/doctype/loyalty_point_entry/test_loyalty_point_entry.py

@@ -3,31 +3,20 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import today
 
-from erpnext.accounts.doctype.loyalty_program.test_loyalty_program import create_records
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestLoyaltyPointEntry(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
+class TestLoyaltyPointEntry(ERPNextTestSuite):
+	def setUp(self):
 		# Create test records
-		create_records()
-		cls.loyalty_program_name = "Test Single Loyalty"
-		cls.customer_name = "Test Loyalty Customer"
-		customer = frappe.get_doc("Customer", cls.customer_name)
-		customer.db_set("loyalty_program", cls.loyalty_program_name)
-
-	@classmethod
-	def tearDownClass(cls):
-		# Delete all Loyalty Point Entries
-		frappe.db.sql("DELETE FROM `tabLoyalty Point Entry` WHERE customer = %s", cls.customer_name)
-		frappe.db.sql("DELETE FROM `tabSales Invoice` WHERE customer = %s", cls.customer_name)
-		frappe.db.commit()
-		# cls.customer.delete()
+		self.loyalty_program_name = "Test Single Loyalty"
+		self.customer_name = "Test Loyalty Customer"
+		customer = frappe.get_doc("Customer", self.customer_name)
+		customer.loyalty_program = self.loyalty_program_name
+		customer.save()
 
 	def create_test_invoice(self, redeem=None):
 		if redeem:
@@ -69,9 +58,10 @@ class TestLoyaltyPointEntry(IntegrationTestCase):
 		self.assertEqual(entry.discretionary_reason, "Customer Appreciation")
 
 	def test_redeem_loyalty_points(self):
-		self.create_test_invoice(redeem=10)
+		self.create_test_invoice()
+		self.create_test_invoice(redeem=7)
 		doc = frappe.get_last_doc("Loyalty Point Entry")
-		self.assertEqual(doc.loyalty_points, -10)
+		self.assertEqual(doc.loyalty_points, -7)
 
 		# Check balance
 		balance = frappe.db.sql(
@@ -83,4 +73,4 @@ class TestLoyaltyPointEntry(IntegrationTestCase):
 			(self.customer_name,),
 		)[0][0]
 
-		self.assertEqual(balance, 75)  # 85 added, 10 redeemed
+		self.assertEqual(balance, 3)  # 10 added, 7 redeemed

erpnext/accounts/doctype/loyalty_program/test_loyalty_program.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import cint, flt, getdate, today
 
 from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
@@ -11,15 +10,10 @@ from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
 	get_loyalty_program_details_with_points,
 )
 from erpnext.accounts.party import get_dashboard_info
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestLoyaltyProgram(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		# create relevant item, customer, loyalty program, etc
-		create_records()
-
+class TestLoyaltyProgram(ERPNextTestSuite):
 	def test_loyalty_points_earned_single_tier(self):
 		frappe.db.set_value("Customer", "Test Loyalty Customer", "loyalty_program", "Test Single Loyalty")
 		# create a new sales invoice
@@ -323,96 +317,3 @@ def create_sales_invoice_record(qty=1):
 			],
 		}
 	)
-
-
-def create_records():
-	# create a new loyalty Account
-	if not frappe.db.exists("Account", "Loyalty - _TC"):
-		frappe.get_doc(
-			{
-				"doctype": "Account",
-				"account_name": "Loyalty",
-				"parent_account": "Direct Expenses - _TC",
-				"company": "_Test Company",
-				"is_group": 0,
-				"account_type": "Expense Account",
-			}
-		).insert()
-
-	# create a new loyalty program Single tier
-	if not frappe.db.exists("Loyalty Program", "Test Single Loyalty"):
-		frappe.get_doc(
-			{
-				"doctype": "Loyalty Program",
-				"loyalty_program_name": "Test Single Loyalty",
-				"auto_opt_in": 1,
-				"from_date": today(),
-				"loyalty_program_type": "Single Tier Program",
-				"conversion_factor": 1,
-				"expiry_duration": 10,
-				"company": "_Test Company",
-				"cost_center": "Main - _TC",
-				"expense_account": "Loyalty - _TC",
-				"collection_rules": [{"tier_name": "Bronce", "collection_factor": 1000, "min_spent": 0}],
-			}
-		).insert()
-
-	# create a new customer
-	if not frappe.db.exists("Customer", "Test Loyalty Customer"):
-		frappe.get_doc(
-			{
-				"customer_group": "_Test Customer Group",
-				"customer_name": "Test Loyalty Customer",
-				"customer_type": "Individual",
-				"doctype": "Customer",
-				"territory": "_Test Territory",
-			}
-		).insert()
-
-	# create a new loyalty program Multiple tier
-	if not frappe.db.exists("Loyalty Program", "Test Multiple Loyalty"):
-		frappe.get_doc(
-			{
-				"doctype": "Loyalty Program",
-				"loyalty_program_name": "Test Multiple Loyalty",
-				"auto_opt_in": 1,
-				"from_date": today(),
-				"loyalty_program_type": "Multiple Tier Program",
-				"conversion_factor": 1,
-				"expiry_duration": 10,
-				"company": "_Test Company",
-				"cost_center": "Main - _TC",
-				"expense_account": "Loyalty - _TC",
-				"collection_rules": [
-					{"tier_name": "Bronze", "collection_factor": 1000, "min_spent": 0},
-					{"tier_name": "Silver", "collection_factor": 1000, "min_spent": 10000},
-					{"tier_name": "Gold", "collection_factor": 1000, "min_spent": 19000},
-				],
-			}
-		).insert()
-
-	# create an item
-	if not frappe.db.exists("Item", "Loyal Item"):
-		frappe.get_doc(
-			{
-				"doctype": "Item",
-				"item_code": "Loyal Item",
-				"item_name": "Loyal Item",
-				"item_group": "All Item Groups",
-				"company": "_Test Company",
-				"is_stock_item": 1,
-				"opening_stock": 100,
-				"valuation_rate": 10000,
-			}
-		).insert()
-
-	# create item price
-	if not frappe.db.exists("Item Price", {"price_list": "Standard Selling", "item_code": "Loyal Item"}):
-		frappe.get_doc(
-			{
-				"doctype": "Item Price",
-				"price_list": "Standard Selling",
-				"item_code": "Loyal Item",
-				"price_list_rate": 10000,
-			}
-		).insert()

erpnext/accounts/doctype/mode_of_payment/test_mode_of_payment.py

@@ -3,10 +3,11 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
+
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestModeofPayment(IntegrationTestCase):
+class TestModeofPayment(ERPNextTestSuite):
 	pass
 
 

erpnext/accounts/doctype/monthly_distribution/test_monthly_distribution.py

@@ -2,9 +2,8 @@
 # See license.txt
 import unittest
 
-import frappe
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestMonthlyDistribution(IntegrationTestCase):
+class TestMonthlyDistribution(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -2,7 +2,6 @@
 # See license.txt
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
 	create_dimension,
@@ -11,17 +10,14 @@ from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension imp
 from erpnext.accounts.doctype.opening_invoice_creation_tool.opening_invoice_creation_tool import (
 	get_temporary_opening_account,
 )
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Customer", "Supplier", "Accounting Dimension"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestOpeningInvoiceCreationTool(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
+class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
+	def setUp(self):
 		if not frappe.db.exists("Company", "_Test Opening Invoice Company"):
 			make_company()
 		create_dimension()
-		return super().setUpClass()
 
 	def make_invoices(
 		self,
@@ -149,9 +145,6 @@ class TestOpeningInvoiceCreationTool(IntegrationTestCase):
 		}
 		self.check_expected_values(invoices, expected_value, invoice_type="Sales")
 
-	def tearDown(self):
-		disable_dimension()
-
 
 def get_opening_invoice_creation_dict(**args):
 	party = "Customer" if args.get("invoice_type", "Sales") == "Sales" else "Supplier"

erpnext/accounts/doctype/party_link/test_party_link.py

@@ -3,8 +3,8 @@
 # import frappe
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPartyLink(IntegrationTestCase):
+class TestPartyLink(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -2556,14 +2556,9 @@ def get_orders_to_be_billed(
 	if not voucher_type:
 		return []
 
-	# Add cost center condition
-	doc = frappe.get_doc({"doctype": voucher_type})
-	condition = ""
-	if doc and hasattr(doc, "cost_center") and doc.cost_center:
-		condition = " and cost_center='%s'" % cost_center
-
 	# dynamic dimension filters
-	active_dimensions = get_dimensions()[0]
+	condition = ""
+	active_dimensions = get_dimensions(True)[0]
 	for dim in active_dimensions:
 		if filters.get(dim.fieldname):
 			condition += f" and {dim.fieldname}='{filters.get(dim.fieldname)}'"

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -4,7 +4,6 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import create_account
@@ -24,14 +23,10 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
 )
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.setup.doctype.employee.test_employee import make_employee
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item", "Currency Exchange"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentEntry(IntegrationTestCase):
-	def tearDown(self):
-		frappe.db.rollback()
-
+class TestPaymentEntry(ERPNextTestSuite):
 	def get_journals_for(self, voucher_type: str, voucher_no: str) -> list:
 		journals = []
 		if voucher_type and voucher_no:
@@ -427,7 +422,7 @@ class TestPaymentEntry(IntegrationTestCase):
 		self.assertEqual(si.payment_schedule[0].outstanding, 0)
 		self.assertEqual(si.payment_schedule[0].discounted_amount, 50)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
 			"allow_multi_currency_invoices_against_single_party_account": 1,
@@ -645,6 +640,7 @@ class TestPaymentEntry(IntegrationTestCase):
 	def test_payment_entry_retrieves_last_exchange_rate(self):
 		from erpnext.setup.doctype.currency_exchange.test_currency_exchange import save_new_records
 
+		self.load_test_records("Currency Exchange")
 		save_new_records(self.globalTestRecords["Currency Exchange"])
 
 		pe = frappe.new_doc("Payment Entry")
@@ -982,6 +978,7 @@ class TestPaymentEntry(IntegrationTestCase):
 	def test_gl_of_multi_currency_payment_transaction(self):
 		from erpnext.setup.doctype.currency_exchange.test_currency_exchange import save_new_records
 
+		self.load_test_records("Currency Exchange")
 		save_new_records(self.globalTestRecords["Currency Exchange"])
 		paid_from = create_account(
 			parent_account="Current Liabilities - _TC",
@@ -1158,7 +1155,7 @@ class TestPaymentEntry(IntegrationTestCase):
 		}
 		self.assertDictEqual(ref_details, expected_response)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
 			"unlink_payment_on_cancellation_of_invoice": 1,
@@ -1253,7 +1250,7 @@ class TestPaymentEntry(IntegrationTestCase):
 		si3.cancel()
 		si3.delete()
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
 			"unlink_payment_on_cancellation_of_invoice": 1,
@@ -1949,7 +1946,7 @@ class TestPaymentEntry(IntegrationTestCase):
 		# 'Is Opening' should always be 'No' for normal advance payments
 		self.assertEqual(gl_with_opening_set, [])
 
-	@IntegrationTestCase.change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
 	def test_delete_linked_exchange_gain_loss_journal(self):
 		from erpnext.accounts.doctype.account.test_account import create_account
 		from erpnext.accounts.doctype.opening_invoice_creation_tool.test_opening_invoice_creation_tool import (

erpnext/accounts/doctype/payment_entry_deduction/payment_entry_deduction.json

@@ -22,6 +22,7 @@
    "reqd": 1
   },
   {
+   "allow_on_submit": 1,
    "fieldname": "cost_center",
    "fieldtype": "Link",
    "in_list_view": 1,
@@ -59,7 +60,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-08-13 06:52:46.130142",
+ "modified": "2026-03-11 14:26:11.312950",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry Deduction",

erpnext/accounts/doctype/payment_gateway_account/test_payment_gateway_account.py

@@ -2,10 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
-
-IGNORE_TEST_RECORD_DEPENDENCIES = ["Payment Gateway"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentGatewayAccount(IntegrationTestCase):
+class TestPaymentGatewayAccount(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -3,7 +3,6 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase
 from frappe.utils import nowdate
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
@@ -11,9 +10,10 @@ from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_pay
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.stock.doctype.item.test_item import create_item
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentLedgerEntry(IntegrationTestCase):
+class TestPaymentLedgerEntry(ERPNextTestSuite):
 	def setUp(self):
 		self.ple = qb.DocType("Payment Ledger Entry")
 		self.create_company()
@@ -21,9 +21,6 @@ class TestPaymentLedgerEntry(IntegrationTestCase):
 		self.create_customer()
 		self.clear_old_entries()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def create_company(self):
 		company_name = "_Test Payment Ledger"
 		company = None
@@ -445,7 +442,7 @@ class TestPaymentLedgerEntry(IntegrationTestCase):
 		self.assertEqual(pl_entries_for_crnote[0], expected_values[0])
 		self.assertEqual(pl_entries_for_crnote[1], expected_values[1])
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"unlink_payment_on_cancellation_of_invoice": 1, "delete_linked_ledger_entries": 1},
 	)
@@ -474,7 +471,7 @@ class TestPaymentLedgerEntry(IntegrationTestCase):
 		si.delete()
 		self.assertRaises(frappe.DoesNotExistError, frappe.get_doc, si.doctype, si.name)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{"unlink_payment_on_cancellation_of_invoice": 1, "delete_linked_ledger_entries": 1},
 	)
@@ -507,7 +504,7 @@ class TestPaymentLedgerEntry(IntegrationTestCase):
 		si.delete()
 		self.assertRaises(frappe.DoesNotExistError, frappe.get_doc, si.doctype, si.name)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
 			"unlink_payment_on_cancellation_of_invoice": 1,

erpnext/accounts/doctype/payment_order/test_payment_order.py

@@ -3,7 +3,6 @@
 
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import getdate
 
 from erpnext.accounts.doctype.bank_transaction.test_bank_transaction import (
@@ -15,9 +14,10 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import (
 	make_payment_order,
 )
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentOrder(IntegrationTestCase):
+class TestPaymentOrder(ERPNextTestSuite):
 	def setUp(self):
 		# generate and use a uniq hash identifier for 'Bank Account' and it's linked GL 'Account' to avoid validation error
 		uniq_identifier = frappe.generate_hash(length=10)
@@ -26,9 +26,6 @@ class TestPaymentOrder(IntegrationTestCase):
 			gl_account=self.gl_account, bank_account_name="Checking Account " + uniq_identifier
 		)
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def test_payment_order_creation_against_payment_entry(self):
 		purchase_invoice = make_purchase_invoice()
 		payment_entry = get_payment_entry(

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -4,7 +4,6 @@
 
 import frappe
 from frappe import qb
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, add_years, flt, getdate, nowdate, today
 from frappe.utils.data import getdate as convert_to_date
 
@@ -17,11 +16,10 @@ from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.stock.doctype.item.test_item import create_item
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentReconciliation(IntegrationTestCase):
+class TestPaymentReconciliation(ERPNextTestSuite):
 	def setUp(self):
 		self.create_company()
 		self.create_item()
@@ -30,9 +28,6 @@ class TestPaymentReconciliation(IntegrationTestCase):
 		self.create_cost_center()
 		self.clear_old_entries()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def create_company(self):
 		company = None
 		if frappe.db.exists("Company", "_Test Payment Reconciliation"):
@@ -1235,7 +1230,7 @@ class TestPaymentReconciliation(IntegrationTestCase):
 		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
 		self.assertCountEqual(payment_vouchers, [je2.name, pe2.name])
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
 			"allow_multi_currency_invoices_against_single_party_account": 1,

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -7,7 +7,6 @@ import unittest
 from unittest.mock import patch
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, nowdate
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
@@ -18,8 +17,7 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sal
 from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.setup.utils import get_exchange_rate
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Currency Exchange", "Journal Entry", "Contact", "Address"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 PAYMENT_URL = "https://example.com/payment"
 
@@ -64,7 +62,7 @@ payment_method = [
 ]
 
 
-class TestPaymentRequest(IntegrationTestCase):
+class TestPaymentRequest(ERPNextTestSuite):
 	def setUp(self):
 		for payment_gateway in payment_gateways:
 			if not frappe.db.get_value("Payment Gateway", payment_gateway["gateway"], "name"):
@@ -101,9 +99,6 @@ class TestPaymentRequest(IntegrationTestCase):
 		self._get_payment_gateway_controller = _get_payment_gateway_controller.start()
 		self.addCleanup(_get_payment_gateway_controller.stop)
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def test_payment_request_linkings(self):
 		so_inr = make_sales_order(currency="INR", do_not_save=True)
 		so_inr.disable_rounded_total = 1
@@ -504,7 +499,7 @@ class TestPaymentRequest(IntegrationTestCase):
 			return_doc=1,
 		)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
 	)
 	def test_multiple_payment_if_partially_paid_for_multi_currency(self):
@@ -622,7 +617,7 @@ class TestPaymentRequest(IntegrationTestCase):
 		self.assertEqual(pr.outstanding_amount, 0)
 		self.assertEqual(pr.grand_total, 20000)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
 	)
 	def test_single_payment_with_payment_term_for_multi_currency(self):

erpnext/accounts/doctype/payment_term/test_payment_term.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentTerm(IntegrationTestCase):
+class TestPaymentTerm(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/payment_term/test_records.json

@@ -1,34 +0,0 @@
-[
-  {
-    "doctype":"Payment Term",
-    "due_date_based_on":"Day(s) after invoice date",
-    "payment_term_name":"_Test N30",
-    "description":"_Test Net 30 Days",
-    "invoice_portion":50,
-    "credit_days":30
-  },
-  {
-    "doctype":"Payment Term",
-    "due_date_based_on":"Day(s) after invoice date",
-    "payment_term_name":"_Test COD",
-    "description":"_Test Cash on Delivery",
-    "invoice_portion":50,
-    "credit_days":0
-  },
-  {
-    "doctype":"Payment Term",
-    "due_date_based_on":"Month(s) after the end of the invoice month",
-    "payment_term_name":"_Test EONM",
-    "description":"_Test End of Next Month",
-    "invoice_portion":100,
-    "credit_months":1
-  },
-  {
-    "doctype":"Payment Term",
-    "due_date_based_on":"Day(s) after invoice date",
-    "payment_term_name":"_Test N30 1",
-    "description":"_Test Net 30 Days",
-    "invoice_portion":100,
-    "credit_days":30
-  }
-]

erpnext/accounts/doctype/payment_terms_template/test_payment_terms_template.py

@@ -3,13 +3,11 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
+
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPaymentTermsTemplate(IntegrationTestCase):
-	def tearDown(self):
-		frappe.delete_doc("Payment Terms Template", "_Test Payment Terms Template For Test", force=1)
-
+class TestPaymentTermsTemplate(ERPNextTestSuite):
 	def test_create_template(self):
 		template = frappe.get_doc(
 			{

erpnext/accounts/doctype/payment_terms_template/test_records.json

@@ -1,60 +0,0 @@
-[
-  {
-    "doctype":"Payment Terms Template",
-    "terms":[
-          {
-            "doctype":"Payment Terms Template Detail",
-            "due_date_based_on":"Day(s) after invoice date",
-            "idx":1,
-            "description":"Cash on Delivery",
-            "invoice_portion":50,
-            "credit_days":0,
-            "credit_months":0,
-            "payment_term":"_Test COD"
-        },
-        {
-            "doctype":"Payment Terms Template Detail",
-            "due_date_based_on":"Day(s) after invoice date",
-            "idx":2,
-            "description":"Net 30 Days ",
-            "invoice_portion":50,
-            "credit_days":30,
-            "credit_months":0,
-            "payment_term":"_Test N30"
-        }
-    ],
-    "template_name":"_Test Payment Term Template"
-  },
-  {
-    "doctype":"Payment Terms Template",
-    "terms":[
-          {
-            "doctype":"Payment Terms Template Detail",
-            "due_date_based_on":"Month(s) after the end of the invoice month",
-            "idx":1,
-            "description":"_Test End of Next Months",
-            "invoice_portion":100,
-            "credit_days":0,
-            "credit_months":1,
-            "payment_term":"_Test EONM"
-        }
-    ],
-    "template_name":"_Test Payment Term Template 1"
-  },
-  {
-    "doctype":"Payment Terms Template",
-    "terms":[
-          {
-            "doctype":"Payment Terms Template Detail",
-            "due_date_based_on":"Day(s) after invoice date",
-            "idx":1,
-            "description":"_Test Net Within 30 days",
-            "invoice_portion":100,
-            "credit_days":30,
-            "credit_months":0,
-            "payment_term":"_Test N30 1"
-        }
-    ],
-    "template_name":"_Test Payment Term Template 3"
-  }
-]

erpnext/accounts/doctype/pegged_currencies/test_pegged_currencies.py

@@ -2,28 +2,3 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase, UnitTestCase
-
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-
-
-class UnitTestPeggedCurrencies(UnitTestCase):
-	"""
-	Unit tests for PeggedCurrencies.
-	Use this class for testing individual functions and methods.
-	"""
-
-	pass
-
-
-class IntegrationTestPeggedCurrencies(IntegrationTestCase):
-	"""
-	Integration tests for PeggedCurrencies.
-	Use this class for testing interactions between multiple components.
-	"""
-
-	pass

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -3,16 +3,16 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import today
 
 from erpnext.accounts.doctype.finance_book.test_finance_book import create_finance_book
 from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.utils import get_fiscal_year
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPeriodClosingVoucher(IntegrationTestCase):
+class TestPeriodClosingVoucher(ERPNextTestSuite):
 	def setUp(self):
 		super().setUp()
 		frappe.db.set_single_value("Accounts Settings", "use_legacy_controller_for_pcv", 1)
@@ -391,6 +391,3 @@ def create_cost_center(cc_name):
 	)
 	costcenter.insert(ignore_if_duplicate=True)
 	return costcenter.name
-
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Customer", "Cost Center"]

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.accounting_dimension.test_accounting_dimension import (
 	create_dimension,
@@ -22,26 +21,14 @@ from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle
 	get_batch_from_bundle,
 )
 from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSClosingEntry(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
-		cls.enterClassContext(cls.change_settings("POS Settings", {"invoice_type": "POS Invoice"}))
-
-	@classmethod
-	def tearDownClass(cls):
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
-
+class TestPOSClosingEntry(ERPNextTestSuite):
 	def setUp(self):
-		# Make stock available for POS Sales
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
+		init_user_and_profile()
 		make_stock_entry(target="_Test Warehouse - _TC", qty=2, basic_rate=100)
-
-	def tearDown(self):
-		frappe.set_user("Administrator")
-		frappe.db.sql("delete from `tabPOS Profile`")
+		frappe.db.set_single_value("POS Settings", "invoice_type", "POS Invoice")
 
 	def test_pos_closing_entry(self):
 		test_user, pos_profile = init_user_and_profile()
@@ -58,6 +45,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		pos_inv2.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		pcv_doc.flags.in_test = True
 		payment = pcv_doc.payment_reconciliation[0]
 
 		self.assertEqual(payment.mode_of_payment, "Cash")
@@ -66,6 +54,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 			if d.mode_of_payment == "Cash":
 				d.closing_amount = 6700
 
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		self.assertEqual(pcv_doc.total_quantity, 2)
@@ -84,6 +73,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		pos_inv.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		self.assertTrue(pcv_doc.name)
@@ -116,6 +106,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		pos_return.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
@@ -145,6 +136,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 			if d.mode_of_payment == "Cash":
 				d.closing_amount = 6700
 
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		pos_inv1.load_from_db()
@@ -198,6 +190,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
 		# will assert coz the new mandatory accounting dimension bank is not set in POS Profile
+		pcv_doc.flags.in_test = True
 		self.assertRaises(frappe.ValidationError, pcv_doc.submit)
 
 		accounting_dimension_department = frappe.get_doc(
@@ -265,6 +258,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		self.assertEqual(batch_qty_with_pos, 0.0)
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		piv_merge = frappe.db.get_value("POS Invoice Merge Log", {"pos_closing_entry": pcv_doc.name}, "name")
@@ -288,6 +282,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		frappe.flags.print_message = True
 
 		pcv_doc.reload()
+		pcv_doc.flags.in_test = True
 		pcv_doc.cancel()
 
 		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
@@ -302,7 +297,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
 		self.assertEqual(batch_qty_with_pos, 10.0)
 
-	@IntegrationTestCase.change_settings("POS Settings", {"invoice_type": "Sales Invoice"})
+	@ERPNextTestSuite.change_settings("POS Settings", {"invoice_type": "Sales Invoice"})
 	def test_closing_entries_with_sales_invoice(self):
 		test_user, pos_profile = init_user_and_profile()
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
@@ -330,6 +325,7 @@ class TestPOSClosingEntry(IntegrationTestCase):
 			if d.mode_of_payment == "Cash":
 				d.closing_amount = 1500
 
+		pcv_doc.flags.in_test = True
 		pcv_doc.submit()
 
 		self.assertEqual(pcv_doc.total_quantity, 15)
@@ -473,7 +469,7 @@ def init_user_and_profile(**args):
 	user = "test@example.com"
 	test_user = frappe.get_doc("User", user)
 
-	roles = ("Accounts Manager", "Accounts User", "Sales Manager")
+	roles = ("Accounts Manager", "Accounts User", "Sales Manager", "Stock User", "Item Manager")
 	test_user.add_roles(*roles)
 	frappe.set_user(user)
 

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -5,7 +5,6 @@ import unittest
 
 import frappe
 from frappe import _
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
 	set_default_account_for_mode_of_payment,
@@ -22,37 +21,34 @@ from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle
 	make_serial_batch_bundle,
 )
 from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSInvoice(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
-		cls.enterClassContext(cls.change_settings("POS Settings", invoice_type="POS Invoice"))
-		make_stock_entry(target="_Test Warehouse - _TC", item_code="_Test Item", qty=800, basic_rate=100)
-		frappe.db.sql("delete from `tabTax Rule`")
-
+class POSInvoiceTestMixin(ERPNextTestSuite):
+	def setUp(self):
 		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
-		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
 
-		cls.test_user, cls.pos_profile = init_user_and_profile()
-		cls.opening_entry = create_opening_entry(cls.pos_profile, cls.test_user.name)
-		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
-		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+		self.load_test_records("Stock Entry")
+		self.test_user, self.pos_profile = init_user_and_profile()
 
-	@classmethod
-	def tearDownClass(cls):
-		frappe.db.sql("delete from `tabPOS Invoice`")
-		opening_entry_doc = frappe.get_doc("POS Opening Entry", cls.opening_entry.name)
-		opening_entry_doc.cancel()
-
-	def tearDown(self):
 		if frappe.session.user != "Administrator":
 			frappe.set_user("Administrator")
 
-		if frappe.db.get_single_value("Selling Settings", "validate_selling_price"):
-			frappe.db.set_single_value("Selling Settings", "validate_selling_price", 0)
+		frappe.db.set_single_value("Selling Settings", "validate_selling_price", 0)
+		frappe.db.set_single_value("POS Settings", "invoice_type", "POS Invoice")
+		make_stock_entry(target="_Test Warehouse - _TC", item_code="_Test Item", qty=800, basic_rate=100)
+		frappe.db.sql("delete from `tabTax Rule`")
+
+		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
+		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+
+
+class TestPOSInvoice(POSInvoiceTestMixin):
+	def setUp(self):
+		super().setUp()
+		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
+
+		self.opening_entry = create_opening_entry(self.pos_profile, self.test_user.name)
 
 	def test_timestamp_change(self):
 		w = create_pos_invoice(do_not_save=1)
@@ -642,9 +638,7 @@ class TestPOSInvoice(IntegrationTestCase):
 		from erpnext.accounts.doctype.loyalty_program.loyalty_program import (
 			get_loyalty_program_details_with_points,
 		)
-		from erpnext.accounts.doctype.loyalty_program.test_loyalty_program import create_records
 
-		create_records()
 		frappe.db.set_value("Customer", "Test Loyalty Customer", "loyalty_program", "Test Single Loyalty")
 		before_lp_details = get_loyalty_program_details_with_points(
 			"Test Loyalty Customer", company="_Test Company", loyalty_program="Test Single Loyalty"
@@ -681,6 +675,7 @@ class TestPOSInvoice(IntegrationTestCase):
 			get_loyalty_program_details_with_points,
 		)
 
+		frappe.db.set_value("Customer", "Test Loyalty Customer", "loyalty_program", "Test Single Loyalty")
 		# add 10 loyalty points
 		pos_inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000, do_not_save=1)
 		pos_inv.append(
@@ -710,134 +705,6 @@ class TestPOSInvoice(IntegrationTestCase):
 		)
 		self.assertEqual(after_redeem_lp_details.loyalty_points, 9)
 
-	def test_merging_into_sales_invoice_with_discount(self):
-		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
-			init_user_and_profile,
-		)
-		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
-			consolidate_pos_invoices,
-		)
-
-		frappe.db.sql("delete from `tabPOS Invoice`")
-		test_user, pos_profile = init_user_and_profile()
-		pos_inv = create_pos_invoice(rate=300, additional_discount_percentage=10, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 270})
-		pos_inv.save()
-		pos_inv.submit()
-
-		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 3200})
-		pos_inv2.save()
-		pos_inv2.submit()
-
-		consolidate_pos_invoices()
-
-		pos_inv.load_from_db()
-		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv.consolidated_invoice, "rounded_total")
-		self.assertEqual(rounded_total, 3470)
-
-	def test_merging_into_sales_invoice_with_discount_and_inclusive_tax(self):
-		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
-			init_user_and_profile,
-		)
-		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
-			consolidate_pos_invoices,
-		)
-
-		frappe.db.sql("delete from `tabPOS Invoice`")
-		test_user, pos_profile = init_user_and_profile()
-		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
-		pos_inv.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 14,
-				"included_in_print_rate": 1,
-			},
-		)
-		pos_inv.save()
-		pos_inv.submit()
-
-		pos_inv2 = create_pos_invoice(rate=300, qty=2, do_not_submit=1)
-		pos_inv2.additional_discount_percentage = 10
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 540})
-		pos_inv2.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 14,
-				"included_in_print_rate": 1,
-			},
-		)
-		pos_inv2.save()
-		pos_inv2.submit()
-
-		consolidate_pos_invoices()
-
-		pos_inv.load_from_db()
-		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv.consolidated_invoice, "rounded_total")
-		self.assertEqual(rounded_total, 840)
-
-	def test_merging_with_validate_selling_price(self):
-		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
-			init_user_and_profile,
-		)
-		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
-			consolidate_pos_invoices,
-		)
-
-		if not frappe.db.get_single_value("Selling Settings", "validate_selling_price"):
-			frappe.db.set_single_value("Selling Settings", "validate_selling_price", 1)
-
-		item = "Test Selling Price Validation"
-		make_item(item, {"is_stock_item": 1})
-		make_purchase_receipt(item_code=item, warehouse="_Test Warehouse - _TC", qty=1, rate=300)
-		frappe.db.sql("delete from `tabPOS Invoice`")
-		test_user, pos_profile = init_user_and_profile()
-		pos_inv = create_pos_invoice(item=item, rate=300, do_not_submit=1)
-		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
-		pos_inv.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 14,
-				"included_in_print_rate": 1,
-			},
-		)
-		self.assertRaises(frappe.ValidationError, pos_inv.submit)
-
-		pos_inv2 = create_pos_invoice(item=item, rate=400, do_not_submit=1)
-		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 400})
-		pos_inv2.append(
-			"taxes",
-			{
-				"charge_type": "On Net Total",
-				"account_head": "_Test Account Service Tax - _TC",
-				"cost_center": "_Test Cost Center - _TC",
-				"description": "Service Tax",
-				"rate": 14,
-				"included_in_print_rate": 1,
-			},
-		)
-		pos_inv2.save()
-		pos_inv2.submit()
-
-		consolidate_pos_invoices()
-
-		pos_inv2.load_from_db()
-		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv2.consolidated_invoice, "rounded_total")
-		self.assertEqual(rounded_total, 400)
-
 	def test_pos_batch_reservation(self):
 		from erpnext.stock.doctype.serial_and_batch_bundle.serial_and_batch_bundle import (
 			get_auto_batch_nos,
@@ -1004,40 +871,39 @@ class TestPOSInvoice(IntegrationTestCase):
 	def test_ignore_pricing_rule(self):
 		from erpnext.accounts.doctype.pricing_rule.test_pricing_rule import make_pricing_rule
 
-		item_price = frappe.get_doc(
-			{
-				"doctype": "Item Price",
-				"item_code": "_Test Item",
-				"price_list": "_Test Price List",
-				"price_list_rate": "450",
-			}
-		)
-		item_price.insert()
+		if not frappe.db.exists(
+			"Item Price",
+			{"item_code": "_Test Item", "price_list": "_Test Price List", "price_list_rate": "450"},
+		):
+			item_price = frappe.get_doc(
+				{
+					"doctype": "Item Price",
+					"item_code": "_Test Item",
+					"price_list": "_Test Price List",
+					"price_list_rate": "450",
+				}
+			)
+			item_price.insert()
+
 		pr = make_pricing_rule(selling=1, priority=5, discount_percentage=10)
 		pr.save()
 
-		try:
-			pos_inv = create_pos_invoice(qty=1, do_not_submit=1)
-			pos_inv.items[0].rate = 300
-			pos_inv.save()
-			self.assertEqual(pos_inv.items[0].discount_percentage, 10)
-			# rate shouldn't change
-			self.assertEqual(pos_inv.items[0].rate, 405)
+		pos_inv = create_pos_invoice(qty=1, do_not_submit=1)
+		pos_inv.items[0].rate = 300
+		pos_inv.save()
+		self.assertEqual(pos_inv.items[0].discount_percentage, 10)
+		# rate shouldn't change
+		self.assertEqual(pos_inv.items[0].rate, 405)
 
-			pos_inv.ignore_pricing_rule = 1
-			pos_inv.save()
-			self.assertEqual(pos_inv.ignore_pricing_rule, 1)
-			# rate should reset since pricing rules are ignored
-			self.assertEqual(pos_inv.items[0].rate, 450)
+		pos_inv.ignore_pricing_rule = 1
+		pos_inv.save()
+		self.assertEqual(pos_inv.ignore_pricing_rule, 1)
+		# rate should reset since pricing rules are ignored
+		self.assertEqual(pos_inv.items[0].rate, 450)
 
-			pos_inv.items[0].rate = 300
-			pos_inv.save()
-			self.assertEqual(pos_inv.items[0].rate, 300)
-
-		finally:
-			item_price.delete()
-			pos_inv.delete()
-			pr.delete()
+		pos_inv.items[0].rate = 300
+		pos_inv.save()
+		self.assertEqual(pos_inv.items[0].rate, 300)
 
 	def test_delivered_serial_no_case(self):
 		from erpnext.accounts.doctype.pos_invoice_merge_log.test_pos_invoice_merge_log import (
@@ -1046,32 +912,26 @@ class TestPOSInvoice(IntegrationTestCase):
 		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 
-		frappe.db.savepoint("before_test_delivered_serial_no_case")
-		try:
-			se = make_serialized_item(self)
-			serial_no = get_serial_nos_from_bundle(se.get("items")[0].serial_and_batch_bundle)[0]
+		se = make_serialized_item(self)
+		serial_no = get_serial_nos_from_bundle(se.get("items")[0].serial_and_batch_bundle)[0]
 
-			dn = create_delivery_note(item_code="_Test Serialized Item With Series", serial_no=[serial_no])
-			delivered_serial_no = get_serial_nos_from_bundle(dn.get("items")[0].serial_and_batch_bundle)[0]
+		dn = create_delivery_note(item_code="_Test Serialized Item With Series", serial_no=[serial_no])
+		delivered_serial_no = get_serial_nos_from_bundle(dn.get("items")[0].serial_and_batch_bundle)[0]
 
-			self.assertEqual(serial_no, delivered_serial_no)
+		self.assertEqual(serial_no, delivered_serial_no)
 
-			init_user_and_profile()
+		init_user_and_profile()
 
-			pos_inv = create_pos_invoice(
-				item_code="_Test Serialized Item With Series",
-				serial_no=[serial_no],
-				qty=1,
-				rate=100,
-				do_not_submit=True,
-				ignore_sabb_validation=True,
-			)
+		pos_inv = create_pos_invoice(
+			item_code="_Test Serialized Item With Series",
+			serial_no=[serial_no],
+			qty=1,
+			rate=100,
+			do_not_submit=True,
+			ignore_sabb_validation=True,
+		)
 
-			self.assertRaises(frappe.ValidationError, pos_inv.submit)
-
-		finally:
-			frappe.db.rollback(save_point="before_test_delivered_serial_no_case")
-			frappe.set_user("Administrator")
+		self.assertRaises(frappe.ValidationError, pos_inv.submit)
 
 	def test_bundle_stock_availability_validation(self):
 		from erpnext.accounts.doctype.pos_invoice.pos_invoice import ProductBundleStockValidationError

erpnext/accounts/doctype/pos_invoice/test_pos_invoice_merge.py

@@ -0,0 +1,164 @@
+# Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
+# See license.txt
+
+import frappe
+
+from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import POSInvoiceTestMixin, create_pos_invoice
+from erpnext.stock.doctype.item.test_item import make_item
+from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestPOSInvoiceMerging(POSInvoiceTestMixin):
+	def clear_pos_data(self):
+		frappe.db.sql("delete from `tabPOS Opening Entry`;")
+		frappe.db.sql("delete from `tabPOS Closing Entry`;")
+		frappe.db.sql("delete from `tabPOS Invoice`;")
+
+	def setUp(self):
+		self.clear_pos_data()
+		super().setUp()
+
+		from erpnext.accounts.doctype.pos_opening_entry.test_pos_opening_entry import create_opening_entry
+
+		self.opening_entry = create_opening_entry(self.pos_profile, self.test_user.name)
+
+	def test_merging_into_sales_invoice_with_discount(self):
+		from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
+			make_closing_entry_from_opening,
+		)
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
+			init_user_and_profile,
+		)
+		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
+			consolidate_pos_invoices,
+		)
+
+		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		pos_inv = create_pos_invoice(rate=300, additional_discount_percentage=10, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 270})
+		pos_inv.save()
+		pos_inv.submit()
+
+		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 3200})
+		pos_inv2.save()
+		pos_inv2.submit()
+
+		closing_entry = make_closing_entry_from_opening(self.opening_entry)
+		consolidate_pos_invoices(closing_entry=closing_entry)  # does DB commit
+
+		pos_inv.load_from_db()
+		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv.consolidated_invoice, "rounded_total")
+		self.assertEqual(rounded_total, 3470)
+
+	def test_merging_into_sales_invoice_with_discount_and_inclusive_tax(self):
+		from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
+			make_closing_entry_from_opening,
+		)
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
+			init_user_and_profile,
+		)
+		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
+			consolidate_pos_invoices,
+		)
+
+		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
+		pos_inv.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Service Tax - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Service Tax",
+				"rate": 14,
+				"included_in_print_rate": 1,
+			},
+		)
+		pos_inv.save()
+		pos_inv.submit()
+
+		pos_inv2 = create_pos_invoice(rate=300, qty=2, do_not_submit=1)
+		pos_inv2.additional_discount_percentage = 10
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 540})
+		pos_inv2.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Service Tax - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Service Tax",
+				"rate": 14,
+				"included_in_print_rate": 1,
+			},
+		)
+		pos_inv2.save()
+		pos_inv2.submit()
+
+		self.closing_entry = make_closing_entry_from_opening(self.opening_entry)
+		consolidate_pos_invoices(closing_entry=self.closing_entry)  # does DB commit
+
+		pos_inv.load_from_db()
+		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv.consolidated_invoice, "rounded_total")
+		self.assertEqual(rounded_total, 840)
+
+	def test_merging_with_validate_selling_price(self):
+		from erpnext.accounts.doctype.pos_closing_entry.pos_closing_entry import (
+			make_closing_entry_from_opening,
+		)
+		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import (
+			init_user_and_profile,
+		)
+		from erpnext.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import (
+			consolidate_pos_invoices,
+		)
+
+		if not frappe.db.get_single_value("Selling Settings", "validate_selling_price"):
+			frappe.db.set_single_value("Selling Settings", "validate_selling_price", 1)
+
+		item = "Test Selling Price Validation"
+		make_item(item, {"is_stock_item": 1})
+		make_purchase_receipt(item_code=item, warehouse="_Test Warehouse - _TC", qty=1, rate=300)
+		frappe.db.sql("delete from `tabPOS Invoice`")
+		test_user, pos_profile = init_user_and_profile()
+		pos_inv = create_pos_invoice(item=item, rate=300, do_not_submit=1)
+		pos_inv.append("payments", {"mode_of_payment": "Cash", "amount": 300})
+		pos_inv.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Service Tax - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Service Tax",
+				"rate": 14,
+				"included_in_print_rate": 1,
+			},
+		)
+		self.assertRaises(frappe.ValidationError, pos_inv.submit)
+
+		pos_inv2 = create_pos_invoice(item=item, rate=400, do_not_submit=1)
+		pos_inv2.append("payments", {"mode_of_payment": "Cash", "amount": 400})
+		pos_inv2.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Service Tax - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Service Tax",
+				"rate": 14,
+				"included_in_print_rate": 1,
+			},
+		)
+		pos_inv2.save()
+		pos_inv2.submit()
+
+		self.closing_entry = make_closing_entry_from_opening(self.opening_entry)
+		consolidate_pos_invoices(closing_entry=self.closing_entry)  # does DB commit
+
+		pos_inv2.load_from_db()
+		rounded_total = frappe.db.get_value("Sales Invoice", pos_inv2.consolidated_invoice, "rounded_total")
+		self.assertEqual(rounded_total, 400)

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -283,7 +283,7 @@ class POSInvoiceMergeLog(Document):
 			base_rounding_adjustment += doc.base_rounding_adjustment
 			base_rounded_total += doc.base_rounded_total
 
-			for d in doc.get("item_wise_tax_details"):
+			for d in doc.get("item_wise_tax_details") or []:
 				row = frappe._dict(
 					item=old_new_item_map[d.item_row],
 					tax=old_new_tax_map[d.tax_row],
@@ -572,7 +572,7 @@ def split_invoices(invoices):
 
 
 def create_merge_logs(invoice_by_customer, closing_entry=None):
-	try:
+	def merge_and_close():
 		for customer, invoices_acc_dim in invoice_by_customer.items():
 			for invoices in invoices_acc_dim.values():
 				for _invoices in split_invoices(invoices):
@@ -594,25 +594,30 @@ def create_merge_logs(invoice_by_customer, closing_entry=None):
 			closing_entry.db_set("error_message", "")
 			closing_entry.update_opening_entry()
 
-	except Exception as e:
-		frappe.db.rollback()
-		message_log = frappe.message_log.pop() if frappe.message_log else str(e)
-		error_message = get_error_message(message_log)
+	if frappe.in_test:
+		merge_and_close()
+	else:
+		try:
+			merge_and_close()
+		except Exception as e:
+			frappe.db.rollback()
+			message_log = frappe.message_log.pop() if frappe.message_log else str(e)
+			error_message = get_error_message(message_log)
 
-		if closing_entry:
-			closing_entry.set_status(update=True, status="Failed")
-			if isinstance(error_message, list):
-				error_message = json.dumps(error_message)
-			closing_entry.db_set("error_message", error_message)
-		raise
+			if closing_entry:
+				closing_entry.set_status(update=True, status="Failed")
+				if isinstance(error_message, list):
+					error_message = json.dumps(error_message)
+				closing_entry.db_set("error_message", error_message)
+			raise
 
-	finally:
-		frappe.db.commit()
-		frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
+		finally:
+			frappe.db.commit()
+			frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
 
 
 def cancel_merge_logs(merge_logs, closing_entry=None):
-	try:
+	def merge_cancel_and_close():
 		for log in merge_logs:
 			merge_log = frappe.get_doc("POS Invoice Merge Log", log)
 			if merge_log.docstatus == 2:
@@ -626,19 +631,24 @@ def cancel_merge_logs(merge_logs, closing_entry=None):
 			closing_entry.db_set("error_message", "")
 			closing_entry.update_opening_entry(for_cancel=True)
 
-	except Exception as e:
-		frappe.db.rollback()
-		message_log = frappe.message_log.pop() if frappe.message_log else str(e)
-		error_message = get_error_message(message_log)
+	if frappe.flags.in_test:
+		merge_cancel_and_close()
+	else:
+		try:
+			merge_cancel_and_close()
+		except Exception as e:
+			frappe.db.rollback()
+			message_log = frappe.message_log.pop() if frappe.message_log else str(e)
+			error_message = get_error_message(message_log)
 
-		if closing_entry:
-			closing_entry.set_status(update=True, status="Submitted")
-			closing_entry.db_set("error_message", error_message)
-		raise
+			if closing_entry:
+				closing_entry.set_status(update=True, status="Submitted")
+				closing_entry.db_set("error_message", error_message)
+			raise
 
-	finally:
-		frappe.db.commit()
-		frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
+		finally:
+			frappe.db.commit()
+			frappe.publish_realtime("closing_process_complete", user=frappe.session.user)
 
 
 def enqueue_job(job, **kwargs):

erpnext/accounts/doctype/pos_invoice_merge_log/test_pos_invoice_merge_log.py

@@ -3,7 +3,6 @@
 import json
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.mode_of_payment.test_mode_of_payment import (
 	set_default_account_for_mode_of_payment,
@@ -19,30 +18,25 @@ from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle
 	get_serial_nos_from_bundle,
 )
 from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSInvoiceMergeLog(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
-		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
-		cls.enterClassContext(cls.change_settings("POS Settings", invoice_type="POS Invoice"))
-		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
-		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
-
+class TestPOSInvoiceMergeLog(ERPNextTestSuite):
 	def setUp(self):
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		mode_of_payment = frappe.get_doc("Mode of Payment", "Bank Draft")
+		self.test_user, self.pos_profile = init_user_and_profile()
+		self.opening_entry = create_opening_entry(self.pos_profile, self.test_user.name)
 
-	def tearDown(self):
-		frappe.set_user("Administrator")
-		frappe.db.sql("delete from `tabPOS Profile`")
-		frappe.db.sql("delete from `tabPOS Invoice`")
+		set_default_account_for_mode_of_payment(mode_of_payment, "_Test Company", "_Test Bank - _TC")
+		frappe.db.set_single_value("POS Settings", "invoice_type", "POS Invoice")
+		frappe.db.set_single_value("Selling Settings", "validate_selling_price", 0)
+
+	def make_closing_entry(self):
+		closing_entry = make_closing_entry_from_opening(self.opening_entry)
+		closing_entry.insert().submit()
+		return closing_entry
 
 	def test_consolidated_invoice_creation(self):
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
 		pos_inv.save()
@@ -58,9 +52,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		pos_inv3.save()
 		pos_inv3.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		pos_inv.load_from_db()
 		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
@@ -71,9 +63,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		self.assertFalse(pos_inv.consolidated_invoice == pos_inv3.consolidated_invoice)
 
 	def test_consolidated_credit_note_creation(self):
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
 		pos_inv.save()
@@ -98,9 +87,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		pos_inv_cn.paid_amount = -300
 		pos_inv_cn.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		pos_inv.load_from_db()
 		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
@@ -118,9 +105,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		self.assertEqual(consolidated_credit_note.payments[1].amount, -200)
 
 	def test_consolidated_invoice_item_taxes(self):
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		inv = create_pos_invoice(qty=1, rate=100, do_not_save=True)
 
 		inv.append(
@@ -157,9 +141,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		inv2.save()
 		inv2.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		inv.load_from_db()
 
@@ -207,9 +189,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 			qty=10,
 		)
 
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		inv = create_pos_invoice(qty=3, rate=10000, do_not_save=True)
 		inv.append(
 			"taxes",
@@ -244,9 +223,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		inv2.insert()
 		inv2.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		inv.load_from_db()
 		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
@@ -264,9 +241,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 			qty=10,
 		)
 
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		inv = create_pos_invoice(qty=6, rate=10000, do_not_save=True)
 		inv.append(
 			"taxes",
@@ -306,16 +280,14 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		inv3.insert()
 		inv3.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		inv.load_from_db()
 		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
 		self.assertNotEqual(consolidated_invoice.outstanding_amount, 800)
 		self.assertEqual(consolidated_invoice.status, "Paid")
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"System Settings", {"number_format": "#,###.###", "currency_precision": 3, "float_precision": 3}
 	)
 	def test_consolidation_round_off_error_3(self):
@@ -325,8 +297,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 			rate=8000,
 			qty=10,
 		)
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
 		item_rates = [69, 59, 29]
 		for _i in [1, 2]:
@@ -363,9 +333,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 			inv.save()
 			inv.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		inv.load_from_db()
 		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
@@ -383,9 +351,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 			qty=10,
 		)
 
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		inv = create_pos_invoice(qty=1, rate=69.5, do_not_save=True)
 		inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 70})
 		inv.insert()
@@ -396,9 +361,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		inv2.insert()
 		inv2.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		inv.load_from_db()
 		consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
@@ -415,14 +378,12 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		The second and third POS Invoice should be consolidated with a single Merge Log
 		"""
 
+		self.load_test_records("Stock Entry")
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 
 		se = make_serialized_item(self)
 		serial_no = get_serial_nos_from_bundle(se.get("items")[0].serial_and_batch_bundle)[0]
 
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		pos_inv = create_pos_invoice(
 			item_code="_Test Serialized Item With Series",
 			serial_no=[serial_no],
@@ -449,9 +410,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		pos_inv2.save()
 		pos_inv2.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		pos_inv.load_from_db()
 		pos_inv2.load_from_db()
@@ -470,9 +429,6 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		create_cost_center(cost_center_name="_Test POS Cost Center 1", is_group=0)
 		create_cost_center(cost_center_name="_Test POS Cost Center 2", is_group=0)
 
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
 		pos_inv.cost_center = "_Test POS Cost Center 1 - _TC"
@@ -491,9 +447,7 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		pos_inv3.save()
 		pos_inv3.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		self.make_closing_entry()
 
 		pos_inv.load_from_db()
 		self.assertTrue(frappe.db.exists("Sales Invoice", pos_inv.consolidated_invoice))
@@ -512,17 +466,12 @@ class TestPOSInvoiceMergeLog(IntegrationTestCase):
 		"""
 		Test if the company is fetched from POS Closing Entry
 		"""
-		test_user, pos_profile = init_user_and_profile()
-		opening_entry = create_opening_entry(pos_profile, test_user.name)
-
 		pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
 		pos_inv.save()
 		pos_inv.submit()
 
-		closing_entry = make_closing_entry_from_opening(opening_entry)
-		closing_entry.insert()
-		closing_entry.submit()
+		closing_entry = self.make_closing_entry()
 
 		self.assertTrue(frappe.db.exists("POS Invoice Merge Log", {"pos_closing_entry": closing_entry.name}))
 

erpnext/accounts/doctype/pos_opening_entry/test_pos_opening_entry.py

@@ -4,35 +4,21 @@ import unittest
 
 import frappe
 from frappe.core.doctype.user_permission.test_user_permission import create_user
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.pos_invoice.test_pos_invoice import create_pos_invoice
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSOpeningEntry(IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
-		cls.enterClassContext(cls.change_settings("POS Settings", {"invoice_type": "POS Invoice"}))
-
-	@classmethod
-	def tearDownClass(cls):
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
-
+class TestPOSOpeningEntry(ERPNextTestSuite):
 	def setUp(self):
-		# Make stock available for POS Sales
-		frappe.db.sql("delete from `tabPOS Opening Entry`")
+		frappe.db.set_single_value("POS Settings", "invoice_type", "POS Invoice")
 		make_stock_entry(target="_Test Warehouse - _TC", qty=2, basic_rate=100)
 		from erpnext.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
 
 		self.init_user_and_profile = init_user_and_profile
 
-	def tearDown(self):
-		frappe.set_user("Administrator")
-		frappe.db.sql("delete from `tabPOS Profile`")
-
 	def test_pos_opening_entry(self):
 		test_user, pos_profile = self.init_user_and_profile()
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
@@ -61,7 +47,9 @@ class TestPOSOpeningEntry(IntegrationTestCase):
 		self.assertEqual(opening_entry_1.status, "Open")
 		self.assertEqual(opening_entry_1.user, test_user.name)
 
-		cashier_user = create_user("test_cashier@example.com", "Accounts Manager", "Sales Manager")
+		cashier_user = create_user(
+			"test_cashier@example.com", "Accounts Manager", "Sales Manager", "Stock User", "System Manager"
+		)
 		frappe.set_user(cashier_user.name)
 
 		pos_profile2 = make_pos_profile(name="_Test POS Profile 2")

erpnext/accounts/doctype/pos_profile/test_pos_profile.py

@@ -3,19 +3,18 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import cint
 
 from erpnext.accounts.doctype.pos_profile.pos_profile import (
 	get_child_nodes,
 )
 from erpnext.stock.get_item_details import get_pos_profile
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSProfile(IntegrationTestCase):
+class TestPOSProfile(ERPNextTestSuite):
 	def test_pos_profile(self):
+		frappe.set_user("Administrator")
 		make_pos_profile()
 
 		pos_profile = get_pos_profile("_Test Company") or {}
@@ -37,8 +36,6 @@ class TestPOSProfile(IntegrationTestCase):
 			self.assertEqual(len(items), products_count[0][0])
 			self.assertEqual(len(customers), customers_count[0][0])
 
-		frappe.db.sql("delete from `tabPOS Profile`")
-
 	def test_disabled_pos_profile_creation(self):
 		make_pos_profile(name="_Test POS Profile 001", disabled=1)
 

erpnext/accounts/doctype/pos_profile_user/test_pos_profile_user.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSProfileUser(IntegrationTestCase):
+class TestPOSProfileUser(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/pos_settings/pos_settings.json

@@ -50,10 +50,10 @@
    "options": "1"
   }
  ],
- "hide_toolbar": 1,
+ "hide_toolbar": 0,
  "issingle": 1,
  "links": [],
- "modified": "2026-01-09 17:30:41.476806",
+ "modified": "2026-03-16 13:28:19.677217",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Settings",

erpnext/accounts/doctype/pos_settings/test_pos_settings.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPOSSettings(IntegrationTestCase):
+class TestPOSSettings(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -5,7 +5,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
@@ -13,17 +12,15 @@ from erpnext.controllers.sales_and_purchase_return import make_return_doc
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.get_item_details import get_item_details
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPricingRule(IntegrationTestCase):
+class TestPricingRule(ERPNextTestSuite):
 	def setUp(self):
 		delete_existing_pricing_rules()
 		setup_pricing_rule_data()
 		self.enterClassContext(self.change_settings("Selling Settings", validate_selling_price=0))
 
-	def tearDown(self):
-		delete_existing_pricing_rules()
-
 	def test_pricing_rule_for_discount(self):
 		from frappe import MandatoryError
 
@@ -416,6 +413,7 @@ class TestPricingRule(IntegrationTestCase):
 		self.assertEqual(item.discount_amount, 110)
 		self.assertEqual(item.rate, 990)
 
+	@ERPNextTestSuite.change_settings("Selling Settings", {"allow_multiple_items": 1})
 	def test_pricing_rule_for_product_discount_on_same_item(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
 		test_record = {
@@ -1191,6 +1189,7 @@ class TestPricingRule(IntegrationTestCase):
 		si.delete()
 		rule.delete()
 
+	@ERPNextTestSuite.change_settings("Selling Settings", {"allow_multiple_items": 1})
 	def test_pricing_rule_for_product_free_item_rounded_qty_and_recursion(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
 		test_record = {
@@ -1236,6 +1235,7 @@ class TestPricingRule(IntegrationTestCase):
 		so.save()
 		self.assertEqual(len(so.items), 1)
 
+	@ERPNextTestSuite.change_settings("Selling Settings", {"allow_multiple_items": 1})
 	def test_pricing_rule_for_product_free_item_round_free_qty(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
 		test_record = {
@@ -1522,9 +1522,6 @@ class TestPricingRule(IntegrationTestCase):
 		pi.cancel()
 
 
-EXTRA_TEST_RECORD_DEPENDENCIES = ["UTM Campaign"]
-
-
 def make_pricing_rule(**args):
 	args = frappe._dict(args)
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -243,8 +243,10 @@ def get_other_conditions(conditions, values, args):
 		if group_condition:
 			conditions += " and " + group_condition
 
-	date = args.get("transaction_date") or frappe.get_value(
-		args.get("doctype"), args.get("name"), "posting_date", ignore=True
+	date = (
+		args.get("transaction_date")
+		or args.get("posting_date")
+		or frappe.get_value(args.get("doctype"), args.get("name"), "posting_date", ignore=True)
 	)
 	if date:
 		conditions += """ and %(transaction_date)s between ifnull(`tabPricing Rule`.valid_from, '2000-01-01')

erpnext/accounts/doctype/process_deferred_accounting/test_process_deferred_accounting.py

@@ -3,7 +3,6 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.account.test_account import create_account
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
@@ -11,9 +10,10 @@ from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
 	create_sales_invoice,
 )
 from erpnext.stock.doctype.item.test_item import create_item
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestProcessDeferredAccounting(IntegrationTestCase):
+class TestProcessDeferredAccounting(ERPNextTestSuite):
 	def test_creation_of_ledger_entry_on_submit(self):
 		"""test creation of gl entries on submission of document"""
 		change_acc_settings(acc_frozen_till_date="2023-05-31", book_deferred_entries_based_on="Months")
@@ -53,6 +53,7 @@ class TestProcessDeferredAccounting(IntegrationTestCase):
 			start_date="2023-05-01",
 			end_date="2023-06-30",
 			type="Income",
+			company="_Test Company",
 		)
 
 		process_deferred_accounting.insert()
@@ -83,6 +84,7 @@ class TestProcessDeferredAccounting(IntegrationTestCase):
 			start_date="2019-01-01",
 			end_date="2019-01-31",
 			type="Income",
+			company="_Test Company",
 		)
 		pda.submit()
 		pda.cancel()

erpnext/accounts/doctype/process_payment_reconciliation/test_process_payment_reconciliation.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestProcessPaymentReconciliation(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestProcessPaymentReconciliation(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/process_payment_reconciliation_log/test_process_payment_reconciliation_log.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestProcessPaymentReconciliationLog(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestProcessPaymentReconciliationLog(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/process_period_closing_voucher/test_process_period_closing_voucher.py

@@ -2,19 +2,3 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
-
-# On IntegrationTestCase, the doctype test records and all
-# link-field test record dependencies are recursively loaded
-# Use these module variables to add/remove to/from that list
-EXTRA_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-IGNORE_TEST_RECORD_DEPENDENCIES = []  # eg. ["User"]
-
-
-class IntegrationTestProcessPeriodClosingVoucher(IntegrationTestCase):
-	"""
-	Integration tests for ProcessPeriodClosingVoucher.
-	Use this class for testing interactions between multiple components.
-	"""
-
-	pass

erpnext/accounts/doctype/process_statement_of_accounts/test_process_statement_of_accounts.py

@@ -3,7 +3,6 @@
 
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, getdate, today
 
 from erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of_accounts import (
@@ -12,26 +11,16 @@ from erpnext.accounts.doctype.process_statement_of_accounts.process_statement_of
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestProcessStatementOfAccounts(AccountsTestMixin, IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
+class TestProcessStatementOfAccounts(AccountsTestMixin, ERPNextTestSuite):
+	def setUp(self):
+		frappe.db.set_single_value("Selling Settings", "validate_selling_price", 0)
 		letterhead = frappe.get_doc("Letter Head", "Company Letterhead - Grey")
 		letterhead.is_default = 0
 		letterhead.save()
-		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
 
-	@classmethod
-	def tearDownClass(cls):
-		super().tearDownClass()
-		letterhead = frappe.get_doc("Letter Head", "Company Letterhead - Grey")
-		letterhead.is_default = 1
-		letterhead.save()
-		frappe.db.commit()  # nosemgrep
-
-	def setUp(self):
 		self.create_company()
 		self.create_customer()
 		self.create_customer(customer_name="Other Customer")
@@ -101,9 +90,6 @@ class TestProcessStatementOfAccounts(AccountsTestMixin, IntegrationTestCase):
 		for age_range in expected_ageing:
 			self.assertEqual(expected_ageing[age_range], ageing.get(age_range))
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 
 def create_process_soa(**args):
 	args = frappe._dict(args)

erpnext/accounts/doctype/process_subscription/test_process_subscription.py

@@ -2,8 +2,10 @@
 # See license.txt
 
 # import frappe
-from frappe.tests import IntegrationTestCase
 
 
-class TestProcessSubscription(IntegrationTestCase):
+from erpnext.tests.utils import ERPNextTestSuite
+
+
+class TestProcessSubscription(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/promotional_scheme/test_promotional_scheme.py

@@ -3,13 +3,13 @@
 import unittest
 
 import frappe
-from frappe.tests import IntegrationTestCase
 
 from erpnext.accounts.doctype.promotional_scheme.promotional_scheme import TransactionExists
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPromotionalScheme(IntegrationTestCase):
+class TestPromotionalScheme(ERPNextTestSuite):
 	def setUp(self):
 		if frappe.db.exists("Promotional Scheme", "_Test Scheme"):
 			frappe.delete_doc("Promotional Scheme", "_Test Scheme")

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.json

@@ -321,7 +321,7 @@
    "fieldtype": "Date",
    "in_list_view": 1,
    "in_standard_filter": 1,
-   "label": "Date",
+   "label": "Posting Date",
    "oldfieldname": "posting_date",
    "oldfieldtype": "Date",
    "print_hide": 1,
@@ -391,7 +391,7 @@
   },
   {
    "collapsible": 1,
-   "collapsible_depends_on": "bill_no",
+   "collapsible_depends_on": "posting_date",
    "fieldname": "supplier_invoice_details",
    "fieldtype": "Section Break",
    "label": "Supplier Invoice"
@@ -1693,7 +1693,7 @@
  "idx": 204,
  "is_submittable": 1,
  "links": [],
- "modified": "2026-03-09 17:15:27.014131",
+ "modified": "2026-03-17 20:44:00.221219",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice",

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -3,7 +3,6 @@
 
 
 import frappe
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, cint, flt, getdate, nowdate, today
 
 import erpnext
@@ -37,24 +36,15 @@ from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle
 )
 from erpnext.stock.doctype.stock_entry.test_stock_entry import get_qty_after_transaction
 from erpnext.stock.tests.test_utils import StockTestMixin
-
-EXTRA_TEST_RECORD_DEPENDENCIES = ["Item", "Cost Center", "Payment Term", "Payment Terms Template"]
-IGNORE_TEST_RECORD_DEPENDENCIES = ["Serial No"]
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
+class TestPurchaseInvoice(ERPNextTestSuite, StockTestMixin):
+	def setUp(self):
 		unlink_payment_on_cancel_of_invoice()
 		frappe.db.set_single_value("Buying Settings", "allow_multiple_items", 1)
-
-	@classmethod
-	def tearDownClass(cls):
-		unlink_payment_on_cancel_of_invoice(0)
-
-	def tearDown(self):
-		frappe.db.rollback()
+		self.load_test_records("Purchase Invoice")
+		self.load_test_records("Journal Entry")
 
 	def test_purchase_invoice_qty(self):
 		pi = make_purchase_invoice(qty=0, do_not_save=True)
@@ -352,6 +342,9 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 			self.assertEqual(expected_values[gle.account][1], gle.debit)
 			self.assertEqual(expected_values[gle.account][2], gle.credit)
 
+	@ERPNextTestSuite.change_settings(
+		"Accounts Settings", {"allow_multi_currency_invoices_against_single_party_account": 1}
+	)
 	def test_purchase_invoice_with_exchange_rate_difference(self):
 		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
 			make_purchase_invoice as create_purchase_invoice,
@@ -375,7 +368,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 
 		# fetching the latest GL Entry with exchange gain and loss account account
 		amount = frappe.db.get_value(
-			"GL Entry", {"account": exchange_gain_loss_account, "voucher_no": pi.name}, "debit"
+			"GL Entry", {"account": exchange_gain_loss_account, "voucher_no": pi.name}, "credit"
 		)
 		discrepancy_caused_by_exchange_rate_diff = abs(
 			pi.items[0].base_net_amount - pr.items[0].base_net_amount
@@ -421,14 +414,14 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 
 		# fetching the latest GL Entry with exchange gain and loss account account
 		amount = frappe.db.get_value(
-			"GL Entry", {"account": exchange_gain_loss_account, "voucher_no": pi.name}, "debit"
+			"GL Entry", {"account": exchange_gain_loss_account, "voucher_no": pi.name}, "credit"
 		)
 
 		discrepancy_caused_by_exchange_rate_diff = abs(
 			pi.items[1].base_net_amount - pr.items[1].base_net_amount
 		)
 
-		self.assertEqual(discrepancy_caused_by_exchange_rate_diff, amount)
+		self.assertEqual(flt(discrepancy_caused_by_exchange_rate_diff, 2), amount)
 
 	def test_purchase_invoice_change_naming_series(self):
 		pi = frappe.copy_doc(self.globalTestRecords["Purchase Invoice"][1])
@@ -509,9 +502,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 			self.assertEqual(tax.tax_amount, expected_values[i][1])
 			self.assertEqual(tax.total, expected_values[i][2])
 
-	@IntegrationTestCase.change_settings(
-		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
-	)
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_with_advance(self):
 		jv = frappe.copy_doc(self.globalTestRecords["Journal Entry"][1])
 		jv.insert()
@@ -562,9 +553,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 			)
 		)
 
-	@IntegrationTestCase.change_settings(
-		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
-	)
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_invoice_with_advance_and_multi_payment_terms(self):
 		jv = frappe.copy_doc(self.globalTestRecords["Journal Entry"][1])
 		jv.insert()
@@ -1289,9 +1278,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 		acc_settings.submit_journal_entriessubmit_journal_entries = 0
 		acc_settings.save()
 
-	@IntegrationTestCase.change_settings(
-		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
-	)
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_gain_loss_with_advance_entry(self):
 		unlink_enabled = frappe.db.get_single_value(
 			"Accounts Settings", "unlink_payment_on_cancellation_of_invoice"
@@ -1492,9 +1479,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 		)
 		frappe.db.set_value("Company", "_Test Company", "exchange_gain_loss_account", original_account)
 
-	@IntegrationTestCase.change_settings(
-		"Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1}
-	)
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"unlink_payment_on_cancellation_of_invoice": 1})
 	def test_purchase_invoice_advance_taxes(self):
 		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 
@@ -2160,7 +2145,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 		rate = flt(sle.stock_value_difference) / flt(sle.actual_qty)
 		self.assertAlmostEqual(rate, 500)
 
-	@IntegrationTestCase.change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"automatically_fetch_payment_terms": 1})
 	def test_payment_allocation_for_payment_terms(self):
 		from erpnext.buying.doctype.purchase_order.test_purchase_order import (
 			create_pr_against_po,
@@ -2287,6 +2272,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 
 	def test_create_purchase_invoice_without_mandatory(self):
 		pi = frappe.new_doc("Purchase Invoice")
+		pi.company = "_Test Company"
 		pi.flags.ignore_mandatory = True
 		pi.insert(ignore_permissions=True)
 
@@ -2295,7 +2281,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 
 		pi.delete()
 
-	@IntegrationTestCase.change_settings("Buying Settings", {"supplier_group": None})
+	@ERPNextTestSuite.change_settings("Buying Settings", {"supplier_group": None})
 	def test_purchase_invoice_without_supplier_group(self):
 		# Create a Supplier
 		test_supplier_name = "_Test Supplier Without Supplier Group"
@@ -2415,6 +2401,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 						"doctype": "Serial No",
 						"item_code": serial_item,
 						"serial_no": serial_no,
+						"company": "_Test Company",
 					}
 				).insert()
 
@@ -2467,11 +2454,6 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 				self.assertEqual(row.rejected_serial_no, serial_nos[2])
 
 	def test_make_pr_and_pi_from_po(self):
-		from erpnext.assets.doctype.asset.test_asset import create_asset_category
-
-		if not frappe.db.exists("Asset Category", "Computers"):
-			create_asset_category()
-
 		item = create_item(
 			item_code="_Test_Item", is_stock_item=0, is_fixed_asset=1, asset_category="Computers"
 		)
@@ -2642,7 +2624,7 @@ class TestPurchaseInvoice(IntegrationTestCase, StockTestMixin):
 
 		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
 
-	@IntegrationTestCase.change_settings(
+	@ERPNextTestSuite.change_settings(
 		"Buying Settings", {"maintain_same_rate": 0, "set_landed_cost_based_on_purchase_invoice_rate": 1}
 	)
 	def test_pr_status_rate_adjusted_from_pi(self):

erpnext/accounts/doctype/purchase_taxes_and_charges_template/test_purchase_taxes_and_charges_template.py

@@ -2,8 +2,8 @@
 # See license.txt
 import unittest
 
-from frappe.tests import IntegrationTestCase
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestPurchaseTaxesandChargesTemplate(IntegrationTestCase):
+class TestPurchaseTaxesandChargesTemplate(ERPNextTestSuite):
 	pass

erpnext/accounts/doctype/repost_accounting_ledger/test_repost_accounting_ledger.py

@@ -4,7 +4,6 @@
 import frappe
 from frappe import qb
 from frappe.query_builder.functions import Sum
-from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, nowdate, today
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
@@ -14,23 +13,17 @@ from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext.stock.doctype.item.test_item import make_item
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import get_gl_entries, make_purchase_receipt
+from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestRepostAccountingLedger(AccountsTestMixin, IntegrationTestCase):
-	@classmethod
-	def setUpClass(cls):
-		super().setUpClass()
-		cls.enterClassContext(cls.change_settings("Selling Settings", validate_selling_price=0))
-
+class TestRepostAccountingLedger(AccountsTestMixin, ERPNextTestSuite):
 	def setUp(self):
 		self.create_company()
 		self.create_customer()
 		self.create_item()
+		frappe.db.set_single_value("Selling Settings", "validate_selling_price", 0)
 		update_repost_settings()
 
-	def tearDown(self):
-		frappe.db.rollback()
-
 	def test_01_basic_functions(self):
 		si = create_sales_invoice(
 			item=self.item,
@@ -121,7 +114,7 @@ class TestRepostAccountingLedger(AccountsTestMixin, IntegrationTestCase):
 		ral.append("vouchers", {"voucher_type": si.doctype, "voucher_no": si.name})
 		self.assertRaises(frappe.ValidationError, ral.save)
 
-	@IntegrationTestCase.change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
+	@ERPNextTestSuite.change_settings("Accounts Settings", {"delete_linked_ledger_entries": 1})
 	def test_04_pcv_validation(self):
 		# Clear old GL entries so PCV can be submitted.
 		gl = frappe.qb.DocType("GL Entry")

erpnext/accounts/doctype/repost_accounting_ledger_settings/repost_accounting_ledger_settings.json

@@ -15,11 +15,11 @@
   }
  ],
  "grid_page_length": 50,
- "hide_toolbar": 1,
+ "hide_toolbar": 0,
  "in_create": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-01-02 18:19:08.888368",
+ "modified": "2026-03-16 13:28:21.312607",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Repost Accounting Ledger Settings",