test: cover Asset Capitalization row validations

fix: Process Payment Reconciliation drops bank/cash and cost center filters

erpnext/accounts/doctype/account_closing_balance/test_account_closing_balance.py

@@ -1,10 +1,59 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-
+from erpnext.accounts.doctype.account_closing_balance.account_closing_balance import (
+	aggregate_with_last_account_closing_balance,
+	generate_key,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
 
+def entry(**overrides):
+	row = {"debit": 0, "credit": 0, "debit_in_account_currency": 0, "credit_in_account_currency": 0}
+	row.update(overrides)
+	return row
+
+
 class TestAccountClosingBalance(ERPNextTestSuite):
-	pass
+	"""The closing-balance snapshot is built by merging this period's entries with the
+	previous period's. These lock the merge/key logic that drives that carry-forward."""
+
+	def test_matching_entries_are_summed(self):
+		# this is how a prior-period balance carries forward into the current one
+		merged = aggregate_with_last_account_closing_balance(
+			[
+				entry(account="Cash - _TC", debit=100, debit_in_account_currency=100),
+				entry(
+					account="Cash - _TC",
+					debit=50,
+					credit=20,
+					debit_in_account_currency=50,
+					credit_in_account_currency=20,
+				),
+			],
+			[],
+		)
+		self.assertEqual(len(merged), 1)
+		row = next(iter(merged.values()))
+		self.assertEqual(row["debit"], 150)
+		self.assertEqual(row["credit"], 20)
+		# the account-currency columns are accumulated in the same pass
+		self.assertEqual(row["debit_in_account_currency"], 150)
+		self.assertEqual(row["credit_in_account_currency"], 20)
+
+	def test_entries_are_kept_separate_per_dimension(self):
+		merged = aggregate_with_last_account_closing_balance(
+			[
+				entry(account="Cash - _TC", cost_center="CC1", debit=100, debit_in_account_currency=100),
+				entry(account="Cash - _TC", cost_center="CC2", debit=40, debit_in_account_currency=40),
+			],
+			[],
+		)
+		self.assertEqual(len(merged), 2)
+
+	def test_period_closing_flag_is_part_of_the_key(self):
+		# a P&L reversal (flag 0) and a closing-account entry (flag 1) for the same
+		# account must not merge, so the flag has to distinguish their keys
+		key_reversal, _ = generate_key(entry(account="Sales - _TC", is_period_closing_voucher_entry=0), [])
+		key_closing, _ = generate_key(entry(account="Sales - _TC", is_period_closing_voucher_entry=1), [])
+		self.assertNotEqual(key_reversal, key_closing)

erpnext/accounts/doctype/bank_guarantee/test_bank_guarantee.py

@@ -1,8 +1,76 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+from frappe.utils import flt
+
+from erpnext.accounts.doctype.bank_guarantee.bank_guarantee import get_voucher_details
+from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
 from erpnext.tests.utils import ERPNextTestSuite
 
+BANK = "_Test BG Bank"
+
 
 class TestBankGuarantee(ERPNextTestSuite):
-	pass
+	"""Bank Guarantee records a guarantee issued/received against a customer or
+	supplier. validate() needs a party; on_submit() needs the bank details filled in."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		if not frappe.db.exists("Bank", BANK):
+			frappe.get_doc({"doctype": "Bank", "bank_name": BANK}).insert()
+
+	def make_bg(self, **args):
+		args = frappe._dict(args)
+		doc = frappe.new_doc("Bank Guarantee")
+		doc.bg_type = args.bg_type or "Receiving"
+		doc.amount = args.amount if args.amount is not None else 1000
+		doc.start_date = args.start_date or "2026-06-01"
+		if args.end_date:
+			doc.end_date = args.end_date
+		doc.customer = args.get("customer", "_Test Customer")
+		doc.supplier = args.get("supplier")
+		# fields on_submit requires — present by default, cleared per-test to assert the guard
+		doc.bank_guarantee_number = args.get("bank_guarantee_number", "BG-001")
+		doc.name_of_beneficiary = args.get("name_of_beneficiary", "Test Beneficiary")
+		doc.bank = args.get("bank", BANK)
+		return doc
+
+	def test_validate_requires_customer_or_supplier(self):
+		doc = self.make_bg(customer=None)
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_submit_requires_guarantee_number(self):
+		doc = self.make_bg(bank_guarantee_number="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_submit_requires_beneficiary_name(self):
+		doc = self.make_bg(name_of_beneficiary="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_submit_requires_bank(self):
+		doc = self.make_bg(bank="")
+		doc.insert()
+		self.assertRaises(frappe.ValidationError, doc.submit)
+
+	def test_valid_guarantee_submits(self):
+		doc = self.make_bg()
+		doc.insert()
+		doc.submit()
+		self.assertEqual(frappe.db.get_value("Bank Guarantee", doc.name, "docstatus"), 1)
+
+	def test_get_voucher_details_for_receiving(self):
+		so = make_sales_order()
+		details = get_voucher_details("Receiving", so.name)
+		self.assertEqual(details.customer, so.customer)
+		self.assertEqual(flt(details.grand_total), flt(so.grand_total))
+
+	def test_end_date_before_start_date_is_not_validated(self):
+		# SUSPECTED BUG: validate() never checks that end_date >= start_date, so a
+		# guarantee that expires before it starts saves cleanly. Locking the current
+		# (wrong) behaviour so a future fix that adds the check trips this test.
+		doc = self.make_bg(start_date="2026-06-30", end_date="2026-06-01")
+		doc.insert()
+		self.assertTrue(frappe.db.exists("Bank Guarantee", doc.name))

erpnext/accounts/doctype/cashier_closing/test_cashier_closing.py

@@ -1,8 +1,67 @@
-# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.tests.utils import ERPNextTestSuite
 
+DATE = "2026-06-15"
+
 
 class TestCashierClosing(ERPNextTestSuite):
-	pass
+	"""Cashier Closing reconciles a shift: it pulls outstanding invoices in a
+	date/time window and rolls payments, expense, custody and returns into net_amount."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_invoice_in_window(self, rate=100):
+		si = create_sales_invoice(rate=rate, qty=1, posting_date=DATE, do_not_submit=True)
+		si.posting_time = "10:30:00"
+		si.submit()
+		si.reload()  # read outstanding_amount as persisted after submit
+		return si
+
+	def make_closing(self, user="Administrator", payments=None, **args):
+		doc = frappe.new_doc("Cashier Closing")
+		doc.user = user
+		doc.date = args.get("date", DATE)
+		doc.from_time = args.get("from_time", "09:00:00")
+		doc.time = args.get("time", "18:00:00")
+		for amount in payments or []:
+			doc.append("payments", {"mode_of_payment": "Cash", "amount": amount})
+		doc.expense = args.get("expense", 0)
+		doc.custody = args.get("custody", 0)
+		doc.returns = args.get("returns", 0)
+		return doc
+
+	def test_from_time_must_be_before_to_time(self):
+		doc = self.make_closing(from_time="18:00:00", time="09:00:00")
+		self.assertRaises(frappe.ValidationError, doc.save)
+
+	def test_equal_from_and_to_time_is_rejected(self):
+		# validate_time uses >=, so a zero-length window is also blocked
+		doc = self.make_closing(from_time="09:00:00", time="09:00:00")
+		self.assertRaises(frappe.ValidationError, doc.save)
+
+	def test_net_amount_rolls_up_outstanding_and_adjustments(self):
+		si = self.make_invoice_in_window(rate=100)
+		doc = self.make_closing(payments=[500], expense=50, custody=30, returns=20)
+		doc.save()
+
+		# the in-window invoice is picked up as outstanding
+		self.assertEqual(doc.outstanding_amount, si.outstanding_amount)
+		# net = payments + outstanding + expense - custody + returns
+		self.assertEqual(doc.net_amount, 500 + si.outstanding_amount + 50 - 30 + 20)
+
+	def test_outstanding_is_scoped_to_the_invoice_owner(self):
+		# The invoice is created by Administrator; a closing for a different user does
+		# not see it. NOTE: get_outstanding keys on Sales Invoice.owner (the document
+		# creator) rather than an explicit cashier/POS-user field, which is fragile when
+		# invoices are created by a shared or system user.
+		self.make_invoice_in_window(rate=100)
+		doc = self.make_closing(user="Guest", payments=[500])
+		doc.save()
+		self.assertEqual(doc.outstanding_amount, 0)
+		self.assertEqual(doc.net_amount, 500)

erpnext/accounts/doctype/item_tax_template/test_item_tax_template.py

@@ -1,8 +1,62 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+TAX_ACCOUNT = "_Test Account VAT - _TC"
+RECEIVABLE_ACCOUNT = "Debtors - _TC"
+
 
 class TestItemTaxTemplate(ERPNextTestSuite):
-	pass
+	"""Item Tax Template validates its tax rows: each account must belong to the
+	company, be a tax-like account type, and appear only once."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_template(self, rows, title="_Test ITT"):
+		doc = frappe.new_doc("Item Tax Template")
+		doc.title = f"{title} {frappe.generate_hash(length=6)}"
+		doc.company = COMPANY
+		for account, rate, not_applicable in rows:
+			doc.append(
+				"taxes",
+				{"tax_type": account, "tax_rate": rate, "not_applicable": not_applicable},
+			)
+		return doc
+
+	def test_valid_template_saves_and_is_named_with_abbr(self):
+		doc = self.make_template([(TAX_ACCOUNT, 9, 0)])
+		doc.insert()
+		self.assertTrue(doc.name.endswith(" - _TC"))
+		self.assertTrue(doc.name.startswith(doc.title))
+
+	def test_duplicate_tax_type_throws(self):
+		doc = self.make_template([(TAX_ACCOUNT, 9, 0), (TAX_ACCOUNT, 5, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_account_of_wrong_company_throws(self):
+		other_account = frappe.db.get_value("Account", {"company": "_Test Company 1", "is_group": 0}, "name")
+		self.assertTrue(other_account, "need a non-group account in _Test Company 1")
+		doc = self.make_template([(other_account, 9, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_disallowed_account_type_throws(self):
+		# a Receivable account is not Tax/Chargeable/Income/Expense
+		doc = self.make_template([(RECEIVABLE_ACCOUNT, 9, 0)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_not_applicable_row_has_rate_zeroed(self):
+		doc = self.make_template([(TAX_ACCOUNT, 18, 1)])
+		doc.insert()
+		self.assertEqual(doc.taxes[0].tax_rate, 0)
+
+	def test_negative_tax_rate_is_accepted(self):
+		# SUSPECTED BUG: validate never bounds tax_rate, so a negative (or >100) rate
+		# saves silently. Locking the current (wrong) behaviour.
+		doc = self.make_template([(TAX_ACCOUNT, -5, 0)])
+		doc.insert()
+		self.assertEqual(doc.taxes[0].tax_rate, -5)

erpnext/accounts/doctype/journal_entry_template/journal_entry_template.py

@@ -45,6 +45,20 @@ class JournalEntryTemplate(Document):
 
 	def validate(self):
 		self.validate_party()
+		self.validate_account_company()
+
+	def validate_account_company(self):
+		"""Each row's account must belong to the template's company."""
+		for account in self.accounts:
+			if (
+				account.account
+				and frappe.get_cached_value("Account", account.account, "company") != self.company
+			):
+				frappe.throw(
+					_("Row {0}: Account {1} does not belong to company {2}").format(
+						account.idx, account.account, self.company
+					)
+				)
 
 	def validate_party(self):
 		"""

erpnext/accounts/doctype/journal_entry_template/test_journal_entry_template.py

@@ -1,9 +1,45 @@
-# Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-# import frappe
+
+import frappe
 
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestJournalEntryTemplate(ERPNextTestSuite):
-	pass
+	"""Journal Entry Template's only real rule is validate_party: party_type is
+	allowed only on Receivable/Payable accounts, and a party needs a party_type."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_template(self, rows, company=COMPANY):
+		doc = frappe.new_doc("Journal Entry Template")
+		doc.template_title = f"_Test JET {frappe.generate_hash(length=6)}"
+		doc.company = company
+		doc.voucher_type = "Journal Entry"
+		doc.naming_series = frappe.get_meta("Journal Entry").get_field("naming_series").options.split("\n")[0]
+		for row in rows:
+			doc.append("accounts", row)
+		return doc
+
+	def test_party_type_only_on_receivable_or_payable_account(self):
+		# Cash is neither Receivable nor Payable, so a party_type here is invalid
+		doc = self.make_template([{"account": "Cash - _TC", "party_type": "Customer"}])
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_party_requires_party_type(self):
+		doc = self.make_template([{"account": "Debtors - _TC", "party": "_Test Customer"}])
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_account_from_other_company_is_rejected(self):
+		other_receivable = frappe.db.get_value(
+			"Account", {"company": "_Test Company 1", "account_type": "Receivable", "is_group": 0}, "name"
+		)
+		self.assertTrue(other_receivable, "need a receivable account in _Test Company 1")
+		doc = self.make_template(
+			[{"account": other_receivable, "party_type": "Customer", "party": "_Test Customer"}]
+		)
+		self.assertRaises(frappe.ValidationError, doc.insert)

erpnext/accounts/doctype/mode_of_payment/test_mode_of_payment.py

@@ -5,9 +5,59 @@ import frappe
 
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestModeofPayment(ERPNextTestSuite):
-	pass
+	"""Mode of Payment validates its per-company default accounts (account company
+	must match the row, no company twice) and blocks disabling while a POS Profile
+	still references it."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_mop(self, accounts=None, enabled=1):
+		doc = frappe.new_doc("Mode of Payment")
+		doc.mode_of_payment = f"_Test MoP {frappe.generate_hash(length=6)}"
+		doc.type = "General"
+		doc.enabled = enabled
+		for company, account in accounts or []:
+			doc.append("accounts", {"company": company, "default_account": account})
+		return doc
+
+	def test_valid_mode_of_payment_saves(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC")])
+		doc.insert()
+		self.assertTrue(doc.name)
+
+	def test_account_of_wrong_company_throws(self):
+		other_account = frappe.db.get_value("Account", {"company": "_Test Company 1", "is_group": 0}, "name")
+		self.assertTrue(other_account, "need a non-group account in _Test Company 1")
+		doc = self.make_mop(accounts=[(COMPANY, other_account)])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_repeating_company_throws(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC"), (COMPANY, "Debtors - _TC")])
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_disabling_mode_referenced_by_pos_profile_is_not_blocked(self):
+		# SUSPECTED BUG: validate_pos_mode_of_payment queries "Sales Invoice Payment"
+		# rows with parenttype "POS Profile", but a POS Profile's payments are stored
+		# as "POS Payment Method" rows. The filter never matches, so the guard is dead
+		# and a mode still referenced by a POS Profile disables without complaint.
+		# Locking the current (wrong) behaviour so a fix to the guard trips this test.
+		from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
+
+		make_pos_profile()  # its payments row references the "Cash" mode of payment
+		cash = frappe.get_doc("Mode of Payment", "Cash")
+		cash.enabled = 0
+		cash.save()
+		self.assertEqual(frappe.db.get_value("Mode of Payment", "Cash", "enabled"), 0)
+
+	def test_disabling_unreferenced_mode_succeeds(self):
+		doc = self.make_mop(accounts=[(COMPANY, "Cash - _TC")], enabled=0)
+		doc.insert()
+		self.assertEqual(doc.enabled, 0)
 
 
 def set_default_account_for_mode_of_payment(mode_of_payment, company, account):

erpnext/accounts/doctype/monthly_distribution/test_monthly_distribution.py

@@ -1,8 +1,67 @@
-# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+from frappe.utils import getdate
+
+from erpnext.accounts.doctype.monthly_distribution.monthly_distribution import (
+	get_percentage,
+	get_periodwise_distribution_data,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestMonthlyDistribution(ERPNextTestSuite):
-	pass
+	"""Monthly Distribution spreads an amount across months. validate() enforces a
+	100% total; get_percentage() sums the months that fall inside a period window."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_distribution(self, allocations):
+		doc = frappe.new_doc("Monthly Distribution")
+		doc.distribution_id = f"_Test MD {frappe.generate_hash(length=6)}"
+		for month, pct in allocations:
+			doc.append("percentages", {"month": month, "percentage_allocation": pct})
+		return doc
+
+	def test_get_months_populates_twelve_even_rows(self):
+		doc = frappe.new_doc("Monthly Distribution")
+		doc.distribution_id = "_Test MD Even"
+		doc.get_months()
+
+		self.assertEqual(len(doc.percentages), 12)
+		self.assertEqual(doc.percentages[0].month, "January")
+		self.assertEqual(doc.percentages[-1].month, "December")
+		self.assertEqual([d.idx for d in doc.percentages], list(range(1, 13)))
+		for d in doc.percentages:
+			self.assertAlmostEqual(d.percentage_allocation, 100.0 / 12, places=4)
+		# the auto-populated rows round to exactly 100 and pass validation
+		doc.validate()
+
+	def test_validate_rejects_total_other_than_100(self):
+		doc = self.make_distribution([("January", 50), ("February", 30)])  # sums to 80
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_get_percentage_sums_period_window(self):
+		doc = self.make_distribution([("January", 50), ("February", 30), ("March", 20)])
+		doc.insert()  # total is 100, so validate passes
+
+		# a quarter starting in January covers Jan+Feb+Mar
+		self.assertEqual(get_percentage(doc, getdate("2026-01-01"), 3), 100)
+		# a single month picks up only that month
+		self.assertEqual(get_percentage(doc, getdate("2026-02-01"), 1), 30)
+		# months with no row simply contribute 0 (there is no guard that all 12 exist)
+		self.assertEqual(get_percentage(doc, getdate("2026-04-01"), 1), 0)
+
+	def test_periodwise_distribution_maps_each_period(self):
+		doc = self.make_distribution([("January", 50), ("February", 30), ("March", 20)])
+		doc.insert()
+
+		period_list = [
+			frappe._dict(key="q1", from_date=getdate("2026-01-01")),
+			frappe._dict(key="q2", from_date=getdate("2026-04-01")),
+		]
+		data = get_periodwise_distribution_data(doc.name, period_list, "Quarterly")
+		self.assertEqual(data["q1"], 100)  # Jan+Feb+Mar
+		self.assertEqual(data["q2"], 0)  # Apr+May+Jun carry no allocation

erpnext/accounts/doctype/party_link/test_party_link.py

@@ -1,9 +1,67 @@
-# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-# import frappe
 
+import frappe
+
+from erpnext.accounts.doctype.party_link.party_link import create_party_link
 from erpnext.tests.utils import ERPNextTestSuite
 
+CUSTOMER = "_Test Customer"
+SUPPLIER = "_Test Supplier"
+SUPPLIER_2 = "_Test Supplier 1"
+
 
 class TestPartyLink(ERPNextTestSuite):
-	pass
+	"""Party Link ties a Customer and a Supplier together as one underlying party.
+	validate() constrains the primary role and blocks duplicate links."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def test_create_party_link_with_customer_primary(self):
+		link = create_party_link("Customer", CUSTOMER, SUPPLIER)
+		self.assertEqual(link.primary_role, "Customer")
+		self.assertEqual(link.secondary_role, "Supplier")
+		self.assertEqual(link.primary_party, CUSTOMER)
+		self.assertEqual(link.secondary_party, SUPPLIER)
+		self.assertTrue(frappe.db.exists("Party Link", link.name))
+
+	def test_create_party_link_with_supplier_primary(self):
+		link = create_party_link("Supplier", SUPPLIER, CUSTOMER)
+		self.assertEqual(link.primary_role, "Supplier")
+		self.assertEqual(link.secondary_role, "Customer")
+		self.assertEqual(link.primary_party, SUPPLIER)
+		self.assertEqual(link.secondary_party, CUSTOMER)
+		self.assertTrue(frappe.db.exists("Party Link", link.name))
+
+	def test_primary_role_must_be_customer_or_supplier(self):
+		doc = frappe.new_doc("Party Link")
+		doc.primary_role = "Employee"
+		doc.primary_party = CUSTOMER
+		doc.secondary_role = "Supplier"
+		doc.secondary_party = SUPPLIER
+		# validate() alone isolates the role rule from the dynamic-link checks
+		self.assertRaises(frappe.ValidationError, doc.validate)
+
+	def test_duplicate_link_throws(self):
+		create_party_link("Customer", CUSTOMER, SUPPLIER)
+		dup = frappe.new_doc("Party Link")
+		dup.primary_role = "Customer"
+		dup.primary_party = CUSTOMER
+		dup.secondary_role = "Supplier"
+		dup.secondary_party = SUPPLIER
+		self.assertRaises(frappe.ValidationError, dup.insert)
+
+	def test_party_can_wrongly_be_primary_in_two_links(self):
+		# SUSPECTED BUG: the uniqueness checks are asymmetric - a party already a
+		# *primary* in another link isn't blocked, so one customer can be linked to two
+		# different suppliers, breaking the 1:1 mapping. Locking the current (wrong)
+		# behaviour so a fix that blocks primary reuse trips this test.
+		create_party_link("Customer", CUSTOMER, SUPPLIER)
+		link2 = frappe.new_doc("Party Link")
+		link2.primary_role = "Customer"
+		link2.primary_party = CUSTOMER
+		link2.secondary_role = "Supplier"
+		link2.secondary_party = SUPPLIER_2
+		link2.insert()
+		self.assertTrue(frappe.db.exists("Party Link", link2.name))

erpnext/accounts/doctype/process_payment_reconciliation/process_payment_reconciliation.py

@@ -106,6 +106,8 @@ def get_pr_instance(doc: str):
 		"party",
 		"receivable_payable_account",
 		"default_advance_account",
+		"bank_cash_account",
+		"cost_center",
 		"from_invoice_date",
 		"to_invoice_date",
 		"from_payment_date",

erpnext/accounts/doctype/process_payment_reconciliation/test_process_payment_reconciliation.py

@@ -1,11 +1,73 @@
-# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
-# import frappe
-
+import frappe
 
+from erpnext.accounts.doctype.process_payment_reconciliation.process_payment_reconciliation import (
+	get_pr_instance,
+)
 from erpnext.tests.utils import ERPNextTestSuite
 
+COMPANY = "_Test Company"
+
 
 class TestProcessPaymentReconciliation(ERPNextTestSuite):
-	pass
+	"""Process Payment Reconciliation validates its accounts against the company,
+	moves to Queued on submit, and hands its filters to a Payment Reconciliation run."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_ppr(self, **args):
+		args = frappe._dict(args)
+		doc = frappe.new_doc("Process Payment Reconciliation")
+		doc.company = COMPANY
+		doc.party_type = "Customer"
+		doc.party = "_Test Customer"
+		doc.receivable_payable_account = args.get("receivable_payable_account", "Debtors - _TC")
+		doc.bank_cash_account = args.get("bank_cash_account")
+		doc.from_invoice_date = args.get("from_invoice_date")
+		doc.to_invoice_date = args.get("to_invoice_date")
+		return doc
+
+	def other_company_account(self, **extra):
+		filters = {"company": "_Test Company 1", "is_group": 0, **extra}
+		account = frappe.db.get_value("Account", filters, "name")
+		self.assertTrue(account, "need a matching account in _Test Company 1")
+		return account
+
+	def test_receivable_account_must_belong_to_company(self):
+		doc = self.make_ppr(receivable_payable_account=self.other_company_account(account_type="Receivable"))
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_bank_cash_account_must_belong_to_company(self):
+		doc = self.make_ppr(bank_cash_account=self.other_company_account())
+		self.assertRaises(frappe.ValidationError, doc.insert)
+
+	def test_submit_sets_status_to_queued(self):
+		doc = self.make_ppr()
+		doc.insert()
+		doc.submit()
+		self.assertEqual(doc.status, "Queued")
+
+	def test_get_pr_instance_copies_filters_and_caps_limits(self):
+		doc = self.make_ppr(from_invoice_date="2026-01-01", to_invoice_date="2026-06-30")
+		doc.insert()
+
+		pr = get_pr_instance(doc.name)
+		self.assertEqual(pr.company, COMPANY)
+		self.assertEqual(pr.party, "_Test Customer")
+		self.assertEqual(pr.receivable_payable_account, "Debtors - _TC")
+		self.assertEqual(str(pr.from_invoice_date), "2026-01-01")
+		# the tool run is capped so a single process can't fetch unbounded rows
+		self.assertEqual(pr.invoice_limit, 1000)
+		self.assertEqual(pr.payment_limit, 1000)
+
+	def test_get_pr_instance_copies_bank_cash_and_cost_center(self):
+		doc = self.make_ppr(bank_cash_account="Cash - _TC")
+		doc.cost_center = "_Test Cost Center - _TC"
+		doc.insert()
+
+		pr = get_pr_instance(doc.name)
+		self.assertEqual(pr.bank_cash_account, "Cash - _TC")
+		self.assertEqual(pr.cost_center, "_Test Cost Center - _TC")

erpnext/accounts/doctype/subscription_plan/subscription_plan.py

@@ -79,7 +79,9 @@ def get_plan_rate(
 		start_date = getdate(start_date)
 		end_date = getdate(end_date)
 
-		no_of_months = relativedelta.relativedelta(end_date, start_date).months + 1
+		delta = relativedelta.relativedelta(end_date, start_date)
+		# include the years component so cross-year spans aren't under-counted
+		no_of_months = delta.years * 12 + delta.months + 1
 		cost = plan.cost * no_of_months
 
 		# Adjust cost if start or end date is not month start or end

erpnext/accounts/doctype/subscription_plan/test_subscription_plan.py

@@ -1,8 +1,54 @@
-# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and Contributors
+# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
 
+import frappe
+
+from erpnext.accounts.doctype.subscription_plan.subscription_plan import get_plan_rate
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestSubscriptionPlan(ERPNextTestSuite):
-	pass
+	"""Subscription Plan validates its interval and computes a rate. The Monthly
+	Rate branch multiplies cost by the number of months in the billing window."""
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+
+	def make_plan(self, **args):
+		args = frappe._dict(args)
+		plan = frappe.new_doc("Subscription Plan")
+		plan.plan_name = f"_Test Plan {frappe.generate_hash(length=6)}"
+		plan.item = args.item or "_Test Item"
+		plan.currency = args.currency or "INR"
+		plan.price_determination = args.price_determination
+		plan.cost = args.cost or 0
+		plan.billing_interval = args.billing_interval or "Month"
+		plan.billing_interval_count = (
+			args.billing_interval_count if args.billing_interval_count is not None else 1
+		)
+		return plan
+
+	def test_billing_interval_count_must_be_positive(self):
+		plan = self.make_plan(price_determination="Fixed Rate", cost=100, billing_interval_count=0)
+		self.assertRaises(frappe.ValidationError, plan.insert)
+
+	def test_fixed_rate_applies_prorate_factor(self):
+		plan = self.make_plan(price_determination="Fixed Rate", cost=100)
+		plan.insert()
+		self.assertEqual(get_plan_rate(plan.name), 100)
+		self.assertEqual(get_plan_rate(plan.name, prorate_factor=0.5), 50)
+
+	def test_monthly_rate_within_year(self):
+		plan = self.make_plan(price_determination="Monthly Rate", cost=100)
+		plan.insert()
+		# Jan 1 - Mar 31 is 3 whole months; month-aligned so proration is 0
+		rate = get_plan_rate(plan.name, start_date="2026-01-01", end_date="2026-03-31")
+		self.assertEqual(rate, 300)
+
+	def test_monthly_rate_across_year_boundary(self):
+		# a 14-month span (Jan 2026 to Feb 2027) bills all 14 months, not just the
+		# 2-month remainder that relativedelta.months alone would give
+		plan = self.make_plan(price_determination="Monthly Rate", cost=100)
+		plan.insert()
+		rate = get_plan_rate(plan.name, start_date="2026-01-01", end_date="2027-02-28")
+		self.assertEqual(rate, 1400)

erpnext/assets/doctype/asset_capitalization/test_asset_capitalization.py

@@ -587,3 +587,47 @@ def get_actual_sle_dict(name):
 		}
 
 	return sle_dict
+
+
+class TestAssetCapitalizationValidation(ERPNextTestSuite):
+	"""Row-level validations for the consumed/target items. Exercised on the document
+	directly (the integration tests above cover the full capitalization posting)."""
+
+	def make_capitalization(self, **fields):
+		doc = frappe.new_doc("Asset Capitalization")
+		doc.company = "_Test Company"
+		doc.update(fields)
+		return doc
+
+	def test_source_items_are_mandatory(self):
+		doc = self.make_capitalization()
+		self.assertRaises(frappe.ValidationError, doc.validate_source_mandatory)
+
+	def test_target_item_must_be_a_fixed_asset(self):
+		# _Test Item is a stock item, not a fixed asset
+		doc = self.make_capitalization(target_item_code="_Test Item")
+		self.assertRaises(frappe.ValidationError, doc.validate_target_item)
+
+	def test_consumed_stock_row_rejects_a_non_stock_item(self):
+		doc = self.make_capitalization()
+		doc.append("stock_items", {"item_code": "_Test Non Stock Item", "stock_qty": 1})
+		self.assertRaises(frappe.ValidationError, doc.validate_consumed_stock_item)
+
+	def test_consumed_stock_row_requires_positive_qty(self):
+		doc = self.make_capitalization()
+		doc.append("stock_items", {"item_code": "_Test Item", "stock_qty": 0})
+		self.assertRaises(frappe.ValidationError, doc.validate_consumed_stock_item)
+
+	def test_service_row_rejects_a_stock_item(self):
+		doc = self.make_capitalization()
+		doc.append("service_items", {"item_code": "_Test Item", "qty": 1, "rate": 100})
+		self.assertRaises(frappe.ValidationError, doc.validate_service_item)
+
+	def test_service_row_requires_positive_qty_and_rate(self):
+		zero_qty = self.make_capitalization()
+		zero_qty.append("service_items", {"item_code": "_Test Non Stock Item", "qty": 0, "rate": 100})
+		self.assertRaises(frappe.ValidationError, zero_qty.validate_service_item)
+
+		zero_rate = self.make_capitalization()
+		zero_rate.append("service_items", {"item_code": "_Test Non Stock Item", "qty": 1, "rate": 0})
+		self.assertRaises(frappe.ValidationError, zero_rate.validate_service_item)

erpnext/stock/report/stock_ledger_invariant_check/stock_ledger_invariant_check.py

@@ -20,6 +20,7 @@ SLE_FIELDS = (
 	"outgoing_rate",
 	"stock_queue",
 	"batch_no",
+	"serial_no",
 	"stock_value",
 	"stock_value_difference",
 	"valuation_rate",
@@ -52,16 +53,16 @@ def add_invariant_check_fields(sles, filters):
 	balance_qty = 0.0
 	balance_stock_value = 0.0
 
-	incorrect_idx = 0
-	precision = frappe.get_precision("Stock Ledger Entry", "actual_qty")
+	incorrect_idx = None
+	float_precision = cint(frappe.db.get_single_value("System Settings", "float_precision")) or 3
+	currency_precision = (
+		cint(frappe.db.get_single_value("System Settings", "currency_precision")) or float_precision
+	)
 	for idx, sle in enumerate(sles):
-		queue = json.loads(sle.stock_queue) if sle.stock_queue else []
-
-		fifo_qty = 0.0
-		fifo_value = 0.0
-		for qty, rate in queue:
-			fifo_qty += qty
-			fifo_value += qty * rate
+		if sle.batch_no:
+			sle.use_batchwise_valuation = frappe.db.get_value(
+				"Batch", sle.batch_no, "use_batchwise_valuation", cache=True
+			)
 
 		if sle.actual_qty < 0:
 			sle.consumption_rate = sle.stock_value_difference / sle.actual_qty
@@ -77,57 +78,67 @@ def add_invariant_check_fields(sles, filters):
 			if balance_qty is None:
 				balance_qty = sle.qty_after_transaction
 
-		sle.fifo_queue_qty = fifo_qty
-		sle.fifo_stock_value = fifo_value
-		sle.fifo_valuation_rate = fifo_value / fifo_qty if fifo_qty else None
 		sle.balance_value_by_qty = (
 			sle.stock_value / sle.qty_after_transaction if sle.qty_after_transaction else None
 		)
 		sle.expected_qty_after_transaction = balance_qty
 		sle.stock_value_from_diff = balance_stock_value
 
-		# set difference fields
 		sle.difference_in_qty = sle.qty_after_transaction - sle.expected_qty_after_transaction
-		sle.fifo_qty_diff = sle.qty_after_transaction - fifo_qty
-		sle.fifo_value_diff = sle.stock_value - fifo_value
-		sle.fifo_valuation_diff = (
-			sle.valuation_rate - sle.fifo_valuation_rate if sle.fifo_valuation_rate else None
-		)
 		sle.valuation_diff = (
 			sle.valuation_rate - sle.balance_value_by_qty if sle.balance_value_by_qty else None
 		)
 		sle.diff_value_diff = sle.stock_value_from_diff - sle.stock_value
 
-		if not incorrect_idx and filters.get("show_incorrect_entries"):
-			if is_sle_has_correct_data(sle, precision):
-				continue
-			else:
-				incorrect_idx = idx
+		if maintains_fifo_queue(sle):
+			add_fifo_fields(sle, sles[idx - 1] if idx else None)
 
-		if idx > 0:
-			sle.fifo_stock_diff = sle.fifo_stock_value - sles[idx - 1].fifo_stock_value
-			sle.fifo_difference_diff = sle.fifo_stock_diff - sle.stock_value_difference
-
-		if sle.batch_no:
-			sle.use_batchwise_valuation = frappe.db.get_value(
-				"Batch", sle.batch_no, "use_batchwise_valuation", cache=True
-			)
+		if incorrect_idx is None and not is_sle_has_correct_data(sle, float_precision, currency_precision):
+			incorrect_idx = idx
 
 	if filters.get("show_incorrect_entries"):
-		if incorrect_idx > 0:
-			sles = sles[cint(incorrect_idx) - 1 :]
-
-		return []
+		if incorrect_idx is None:
+			return []
+		return sles[max(incorrect_idx - 1, 0) :]
 
 	return sles
 
 
-def is_sle_has_correct_data(sle, precision):
-	if flt(sle.difference_in_qty, precision) != 0.0 or flt(sle.diff_value_diff, precision) != 0:
-		print(flt(sle.difference_in_qty, precision), flt(sle.diff_value_diff, precision))
-		return False
+def maintains_fifo_queue(sle):
+	# no queue is maintained for serialized/batchwise-valued stock
+	return not (
+		sle.serial_and_batch_bundle or sle.serial_no or (sle.batch_no and sle.use_batchwise_valuation)
+	)
 
-	return True
+
+def add_fifo_fields(sle, prev_sle):
+	queue = json.loads(sle.stock_queue) if sle.stock_queue else []
+
+	fifo_qty = 0.0
+	fifo_value = 0.0
+	for qty, rate in queue:
+		fifo_qty += qty
+		fifo_value += qty * rate
+
+	sle.fifo_queue_qty = fifo_qty
+	sle.fifo_stock_value = fifo_value
+	sle.fifo_valuation_rate = fifo_value / fifo_qty if fifo_qty else None
+	sle.fifo_qty_diff = sle.qty_after_transaction - fifo_qty
+	sle.fifo_value_diff = sle.stock_value - fifo_value
+	sle.fifo_valuation_diff = (
+		sle.valuation_rate - sle.fifo_valuation_rate if sle.fifo_valuation_rate else None
+	)
+	# prev row may not maintain a queue; H and H - F stay blank across the gap
+	if prev_sle and prev_sle.fifo_stock_value is not None:
+		sle.fifo_stock_diff = sle.fifo_stock_value - prev_sle.fifo_stock_value
+		sle.fifo_difference_diff = sle.fifo_stock_diff - sle.stock_value_difference
+
+
+def is_sle_has_correct_data(sle, float_precision, currency_precision):
+	return (
+		flt(sle.difference_in_qty, float_precision) == 0.0
+		and flt(sle.diff_value_diff, currency_precision) == 0.0
+	)
 
 
 def get_columns():

erpnext/stock/report/stock_ledger_invariant_check/test_stock_ledger_invariant_check.py

@@ -42,3 +42,35 @@ class TestStockLedgerInvariantCheck(ERPNextTestSuite):
 		data = self.run_report(item_code=item)
 
 		self.assertEqual(data[-1].qty_after_transaction, 11)
+
+	def test_show_incorrect_entries(self):
+		item = self.make_movements()
+
+		self.assertEqual(self.run_report(item_code=item, show_incorrect_entries=1), [])
+
+		sle = frappe.get_last_doc(
+			"Stock Ledger Entry", {"item_code": item, "warehouse": WAREHOUSE, "is_cancelled": 0}
+		)
+		frappe.db.set_value(
+			"Stock Ledger Entry", sle.name, "qty_after_transaction", sle.qty_after_transaction + 5
+		)
+
+		data = self.run_report(item_code=item, show_incorrect_entries=1)
+		self.assertEqual(len(data), 2)  # incorrect entry + one before it for context
+		self.assertEqual(data[-1].name, sle.name)
+
+	def test_batch_item_skips_fifo_queue_checks(self):
+		from erpnext.stock.doctype.item.test_item import make_item
+
+		item = make_item(
+			properties={"has_batch_no": 1, "create_new_batch": 1, "batch_number_series": "SLIC-BAT-.####"}
+		).name
+		make_stock_entry(item_code=item, to_warehouse=WAREHOUSE, qty=10, rate=100)
+
+		data = self.run_report(item_code=item)
+		self.assertTrue(data)
+		for row in data:
+			self.assertIsNone(row.fifo_qty_diff)
+			self.assertIsNone(row.fifo_value_diff)
+
+		self.assertEqual(self.run_report(item_code=item, show_incorrect_entries=1), [])

erpnext/stock/report/stock_ledger_variance/stock_ledger_variance.py

@@ -205,7 +205,10 @@ def get_data(filters=None):
 
 	data = []
 	if item_warehouse_map:
-		precision = cint(frappe.db.get_single_value("System Settings", "float_precision"))
+		float_precision = cint(frappe.db.get_single_value("System Settings", "float_precision")) or 3
+		currency_precision = (
+			cint(frappe.db.get_single_value("System Settings", "currency_precision")) or float_precision
+		)
 
 		for item_warehouse in item_warehouse_map:
 			report_data = stock_ledger_invariant_check(item_warehouse)
@@ -215,7 +218,11 @@ def get_data(filters=None):
 
 			for row in report_data:
 				if has_difference(
-					row, precision, filters.difference_in, item_warehouse.valuation_method or valuation_method
+					row,
+					float_precision,
+					currency_precision,
+					filters.difference_in,
+					item_warehouse.valuation_method or valuation_method,
 				):
 					row.update(
 						{
@@ -261,23 +268,26 @@ def get_item_warehouse_combinations(filters: dict | None = None) -> dict:
 	return query.run(as_dict=1)
 
 
-def has_difference(row, precision, difference_in, valuation_method):
+def has_difference(row, float_precision, currency_precision, difference_in, valuation_method):
 	if valuation_method == "Moving Average":
-		qty_diff = flt(row.difference_in_qty, precision)
-		value_diff = flt(row.diff_value_diff, precision)
-		valuation_diff = flt(row.valuation_diff, precision)
+		qty_diff = flt(row.difference_in_qty, float_precision)
+		value_diff = flt(row.diff_value_diff, currency_precision)
+		valuation_diff = flt(row.valuation_diff, currency_precision)
 	else:
-		qty_diff = flt(row.difference_in_qty, precision)
-		value_diff = flt(row.diff_value_diff, precision)
+		qty_diff = flt(row.difference_in_qty, float_precision)
+		value_diff = flt(row.diff_value_diff, currency_precision)
 
 		if row.stock_queue and json.loads(row.stock_queue):
 			value_diff = value_diff or (
-				flt(row.fifo_value_diff, precision) or flt(row.fifo_difference_diff, precision)
+				flt(row.fifo_value_diff, currency_precision)
+				or flt(row.fifo_difference_diff, currency_precision)
 			)
 
-			qty_diff = qty_diff or flt(row.fifo_qty_diff, precision)
+			qty_diff = qty_diff or flt(row.fifo_qty_diff, float_precision)
 
-		valuation_diff = flt(row.valuation_diff, precision) or flt(row.fifo_valuation_diff, precision)
+		valuation_diff = flt(row.valuation_diff, currency_precision) or flt(
+			row.fifo_valuation_diff, currency_precision
+		)
 
 	if difference_in == "Qty" and qty_diff:
 		return True
@@ -287,3 +297,5 @@ def has_difference(row, precision, difference_in, valuation_method):
 		return True
 	elif difference_in not in ["Qty", "Value", "Valuation"] and (qty_diff or value_diff or valuation_diff):
 		return True
+
+	return False

erpnext/stock/stock_ledger.py

@@ -1204,7 +1204,11 @@ class update_entries_after:
 			self.wh_data.stock_queue = json.loads(stock_queue[0]) if stock_queue else []
 
 		self.wh_data.stock_value = round_off_if_near_zero(self.wh_data.stock_value + doc.total_amount)
-		self.wh_data.qty_after_transaction += flt(doc.total_qty, self.flt_precision)
+		# Replay the immutable qty recorded on the SLE at submission, not the bundle's recomputed
+		# total_qty. A valuation repost must never rewrite physical quantities; if the bundle's child
+		# rows were edited after submission, doc.total_qty would silently corrupt qty_after_transaction
+		# (and every downstream balance). sle.actual_qty is the frozen movement for this entry.
+		self.wh_data.qty_after_transaction += flt(sle.actual_qty, self.flt_precision)
 		if flt(self.wh_data.qty_after_transaction, self.flt_precision):
 			self.wh_data.valuation_rate = flt(self.wh_data.stock_value, self.flt_precision) / flt(
 				self.wh_data.qty_after_transaction, self.flt_precision