def test_total_purchase_cost_for_project(self):
existing_purchase_cost = frappe.db.sql("""select sum(base_net_amount)
from `tabPurchase Invoice Item` where project = '_Test Project' and docstatus=1"""
)
existing_purchase_cost = existing_purchase_cost and existing_purchase_cost[
0][0] or 0
pi = make_purchase_invoice(currency="USD",
conversion_rate=60,
project="_Test Project")
self.assertEqual(
frappe.db.get_value("Project", "_Test Project",
"total_purchase_cost"),
existing_purchase_cost + 15000)
pi1 = make_purchase_invoice(qty=10, project="_Test Project")
self.assertEqual(
frappe.db.get_value("Project", "_Test Project",
"total_purchase_cost"),
existing_purchase_cost + 15500)
pi1.cancel()
self.assertEqual(
frappe.db.get_value("Project", "_Test Project",
"total_purchase_cost"),
existing_purchase_cost + 15000)
pi.cancel()
self.assertEqual(
frappe.db.get_value("Project", "_Test Project",
"total_purchase_cost"), existing_purchase_cost)
def test_return_purchase_invoice(self):
set_perpetual_inventory()
pi = make_purchase_invoice()
return_pi = make_purchase_invoice(is_return=1,
return_against=pi.name,
qty=-2)
# check gl entries for return
gl_entries = frappe.db.sql("""select account, debit, credit
from `tabGL Entry` where voucher_type=%s and voucher_no=%s
order by account desc""", ("Purchase Invoice", return_pi.name),
as_dict=1)
self.assertTrue(gl_entries)
expected_values = {
"Creditors - _TC": [100.0, 0.0],
"Stock Received But Not Billed - _TC": [0.0, 100.0],
}
for gle in gl_entries:
self.assertEqual(expected_values[gle.account][0], gle.debit)
self.assertEqual(expected_values[gle.account][1], gle.credit)
set_perpetual_inventory(0)
def test_make_purchase_invoice_from_pr_with_returned_qty_duplicate_items(self):
pr1 = make_purchase_receipt(qty=8, do_not_submit=True)
pr1.append("items", {
"item_code": "_Test Item",
"warehouse": "_Test Warehouse - _TC",
"qty": 1,
"received_qty": 1,
"rate": 100,
"conversion_factor": 1.0,
})
pr1.submit()
pi1 = make_purchase_invoice(pr1.name)
pi1.items[0].qty = 4
pi1.items.pop(1)
pi1.save()
pi1.submit()
pr2 = make_purchase_receipt(is_return=1, return_against=pr1.name, qty=-2, do_not_submit=True)
pr2.items[0].purchase_receipt_item = pr1.items[0].name
pr2.submit()
pi2 = make_purchase_invoice(pr1.name)
self.assertEquals(pi2.items[0].qty, 2)
self.assertEquals(pi2.items[1].qty, 1)
def test_update_stock_and_purchase_return(self):
actual_qty_0 = get_qty_after_transaction()
pi = make_purchase_invoice(update_stock=1,
posting_date=frappe.utils.nowdate(),
posting_time=frappe.utils.nowtime())
actual_qty_1 = get_qty_after_transaction()
self.assertEqual(actual_qty_0 + 5, actual_qty_1)
# return entry
pi1 = make_purchase_invoice(is_return=1,
return_against=pi.name,
qty=-2,
rate=50,
update_stock=1)
actual_qty_2 = get_qty_after_transaction()
self.assertEqual(actual_qty_1 - 2, actual_qty_2)
pi1.cancel()
self.assertEqual(actual_qty_1, get_qty_after_transaction())
pi.reload()
pi.cancel()
self.assertEqual(actual_qty_0, get_qty_after_transaction())
def test_multi_currency_gle(self):
set_perpetual_inventory(0)
pi = make_purchase_invoice(supplier="_Test Supplier USD",
credit_to="_Test Payable USD - _TC",
currency="USD",
conversion_rate=50)
gl_entries = frappe.db.sql(
"""select account, account_currency, debit, credit,
debit_in_account_currency, credit_in_account_currency
from `tabGL Entry` where voucher_type='Purchase Invoice' and voucher_no=%s
order by account asc""",
pi.name,
as_dict=1)
self.assertTrue(gl_entries)
expected_values = {
"_Test Payable USD - _TC": {
"account_currency": "USD",
"debit": 0,
"debit_in_account_currency": 0,
"credit": 12500,
"credit_in_account_currency": 250
},
"_Test Account Cost for Goods Sold - _TC": {
"account_currency": "INR",
"debit": 12500,
"debit_in_account_currency": 12500,
"credit": 0,
"credit_in_account_currency": 0
}
}
for field in ("account_currency", "debit", "debit_in_account_currency",
"credit", "credit_in_account_currency"):
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_values[gle.account][field],
gle[field])
# Check for valid currency
pi1 = make_purchase_invoice(supplier="_Test Supplier USD",
credit_to="_Test Payable USD - _TC",
do_not_save=True)
self.assertRaises(InvalidCurrency, pi1.save)
# cancel
pi.cancel()
gle = frappe.db.sql(
"""select name from `tabGL Entry`
where voucher_type='Sales Invoice' and voucher_no=%s""", pi.name)
self.assertFalse(gle)
def test_purchase_receipt_return(self):
actual_qty_0 = get_qty_after_transaction()
# submit purchase receipt
pr = make_purchase_receipt(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=5)
actual_qty_1 = get_qty_after_transaction()
self.assertEquals(actual_qty_0 + 5, actual_qty_1)
pi_doc = make_purchase_invoice(pr.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Payable - _TC"
for d in pi.get("items"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("taxes"):
d.cost_center = "_Test Cost Center - _TC"
pi.insert()
pi.submit()
# submit purchase return
se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC",
qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name)
actual_qty_2 = get_qty_after_transaction()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
return se, pr.name
def test_debit_note(self):
from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
from erpnext.accounts.utils import get_balance_on_voucher
pi = make_purchase_invoice(item_code="_Test Item",
qty=(5 * -1),
rate=500,
is_return=1)
outstanding_amount = get_balance_on_voucher(pi.doctype, pi.name,
"Supplier", pi.supplier,
"Creditors - _TC")
self.assertEqual(pi.outstanding_amount, outstanding_amount)
pe = get_payment_entry("Purchase Invoice",
pi.name,
bank_account="_Test Bank - _TC")
pe.reference_no = "1"
pe.reference_date = nowdate()
pe.paid_from_account_currency = pi.currency
pe.paid_to_account_currency = pi.currency
pe.source_exchange_rate = 1
pe.target_exchange_rate = 1
pe.paid_amount = pi.grand_total * -1
pe.insert()
pe.submit()
pi_doc = frappe.get_doc('Purchase Invoice', pi.name)
self.assertEqual(pi_doc.outstanding_amount, 0)
def test_purchase_invoice_for_disable_allow_cost_center_in_entry_of_bs_account(
self):
accounts_settings = frappe.get_doc('Accounts Settings',
'Accounts Settings')
accounts_settings.allow_cost_center_in_entry_of_bs_account = 0
accounts_settings.save()
cost_center = "_Test Cost Center - _TC"
pi = make_purchase_invoice(credit_to="Creditors - _TC")
expected_values = {
"Creditors - _TC": {
"cost_center": None
},
"_Test Account Cost for Goods Sold - _TC": {
"cost_center": cost_center
}
}
gl_entries = frappe.db.sql(
"""select account, cost_center, account_currency, debit, credit,
debit_in_account_currency, credit_in_account_currency
from `tabGL Entry` where voucher_type='Purchase Invoice' and voucher_no=%s
order by account asc""",
pi.name,
as_dict=1)
self.assertTrue(gl_entries)
for gle in gl_entries:
self.assertEqual(expected_values[gle.account]["cost_center"],
gle.cost_center)
def _test_purchase_return_return_against_purchase_order(self):
actual_qty_0 = get_qty_after_transaction()
from erpnext.buying.doctype.purchase_order.test_purchase_order import (
test_records as purchase_order_test_records,
)
from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_receipt, make_purchase_invoice
# submit purchase receipt
po = frappe.copy_doc(purchase_order_test_records[0])
po.transaction_date = nowdate()
po.is_subcontracted = None
po.get("items")[0].item_code = "_Test Item"
po.get("items")[0].rate = 50
po.insert()
po.submit()
pr_doc = make_purchase_receipt(po.name)
pr = frappe.get_doc(pr_doc)
pr.posting_date = po.transaction_date
pr.insert()
pr.submit()
actual_qty_1 = get_qty_after_transaction()
self.assertEquals(actual_qty_0 + 10, actual_qty_1)
pi_doc = make_purchase_invoice(po.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Payable - _TC"
for d in pi.get("items"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("taxes"):
d.cost_center = "_Test Cost Center - _TC"
pi.run_method("calculate_taxes_and_totals")
pi.bill_no = "NA"
pi.insert()
pi.submit()
# submit purchase return
se = make_stock_entry(
item_code="_Test Item",
source="_Test Warehouse - _TC",
qty=5,
purpose="Purchase Return",
purchase_receipt_no=pr.name,
)
actual_qty_2 = get_qty_after_transaction()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
return se, pr.name
def test_auto_batch(self):
item_code = frappe.db.get_value('Item', {
'has_batch_no': 1,
'create_new_batch': 1
}, 'name')
if not item_code:
doc = frappe.get_doc({
'doctype': 'Item',
'is_stock_item': 1,
'item_code': 'test batch item',
'item_group': 'Products',
'has_batch_no': 1,
'create_new_batch': 1
}).insert(ignore_permissions=True)
item_code = doc.name
pi = make_purchase_invoice(update_stock=1,
posting_date=frappe.utils.nowdate(),
posting_time=frappe.utils.nowtime(),
item_code=item_code)
self.assertTrue(
frappe.db.get_value('Batch', {
'item': item_code,
'reference_name': pi.name
}))
def test_purchase_invoice_blocked_invoice_must_be_in_future(self):
pi = make_purchase_invoice(do_not_save=True)
pi.release_date = nowdate()
self.assertRaises(frappe.ValidationError, pi.save)
pi.release_date = ''
pi.save()
def test_purchase_invoice_for_is_paid_and_update_stock_gl_entry_with_perpetual_inventory(
self):
set_perpetual_inventory()
pi = make_purchase_invoice(update_stock=1,
posting_date=frappe.utils.nowdate(),
posting_time=frappe.utils.nowtime(),
cash_bank_account="Cash - _TC",
is_paid=1)
gl_entries = frappe.db.sql(
"""select account, account_currency, sum(debit) as debit,
sum(credit) as credit, debit_in_account_currency, credit_in_account_currency
from `tabGL Entry` where voucher_type='Purchase Invoice' and voucher_no=%s
group by account, voucher_no order by account asc;""",
pi.name,
as_dict=1)
stock_in_hand_account = get_inventory_account(
pi.company,
pi.get("items")[0].warehouse)
self.assertTrue(gl_entries)
expected_gl_entries = dict((d[0], d) for d in [[
pi.credit_to, 250.0, 250.0
], [stock_in_hand_account, 250.0, 0.0], ["Cash - _TC", 0.0, 250.0]])
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_gl_entries[gle.account][0], gle.account)
self.assertEqual(expected_gl_entries[gle.account][1], gle.debit)
self.assertEqual(expected_gl_entries[gle.account][2], gle.credit)
def test_purchase_receipt_return(self):
actual_qty_0 = get_qty_after_transaction()
# submit purchase receipt
pr = make_purchase_receipt(item_code="_Test Item", warehouse="_Test Warehouse - _TC", qty=5)
actual_qty_1 = get_qty_after_transaction()
self.assertEquals(actual_qty_0 + 5, actual_qty_1)
pi_doc = make_purchase_invoice(pr.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Payable - _TC"
for d in pi.get("items"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("taxes"):
d.cost_center = "_Test Cost Center - _TC"
pi.insert()
pi.submit()
# submit purchase return
se = make_stock_entry(item_code="_Test Item", source="_Test Warehouse - _TC",
qty=5, purpose="Purchase Return", purchase_receipt_no=pr.name)
actual_qty_2 = get_qty_after_transaction()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
return se, pr.name
def test_make_pi_without_terms(self):
pi = make_purchase_invoice(do_not_save=1)
self.assertFalse(pi.get('payment_schedule'))
pi.insert()
self.assertTrue(pi.get('payment_schedule'))
def test_make_purchase_invoice(self):
if not frappe.db.exists('Payment Terms Template', '_Test Payment Terms Template For Purchase Invoice'):
frappe.get_doc({
'doctype': 'Payment Terms Template',
'template_name': '_Test Payment Terms Template For Purchase Invoice',
'allocate_payment_based_on_payment_terms': 1,
'terms': [
{
'doctype': 'Payment Terms Template Detail',
'invoice_portion': 50.00,
'credit_days_based_on': 'Day(s) after invoice date',
'credit_days': 00
},
{
'doctype': 'Payment Terms Template Detail',
'invoice_portion': 50.00,
'credit_days_based_on': 'Day(s) after invoice date',
'credit_days': 30
}]
}).insert()
template = frappe.db.get_value(
'Payment Terms Template', '_Test Payment Terms Template For Purchase Invoice')
old_template_in_supplier = frappe.db.get_value(
"Supplier", "_Test Supplier", "payment_terms")
frappe.db.set_value("Supplier", "_Test Supplier",
"payment_terms", template)
pr = make_purchase_receipt(do_not_save=True)
self.assertRaises(frappe.ValidationError,
make_purchase_invoice, pr.name)
pr.submit()
pi = make_purchase_invoice(pr.name)
self.assertEqual(pi.doctype, "Purchase Invoice")
self.assertEqual(len(pi.get("items")), len(pr.get("items")))
# test maintaining same rate throughout purchade cycle
pi.get("items")[0].rate = 200
self.assertRaises(frappe.ValidationError, frappe.get_doc(pi).submit)
# test if payment terms are fetched and set in PI
self.assertEqual(pi.payment_terms_template, template)
self.assertEqual(
pi.payment_schedule[0].payment_amount, flt(pi.grand_total)/2)
self.assertEqual(pi.payment_schedule[0].invoice_portion, 50)
self.assertEqual(
pi.payment_schedule[1].payment_amount, flt(pi.grand_total)/2)
self.assertEqual(pi.payment_schedule[1].invoice_portion, 50)
# teardown
pi.delete() # draft PI
pr.cancel()
frappe.db.set_value("Supplier", "_Test Supplier",
"payment_terms", old_template_in_supplier)
frappe.get_doc('Payment Terms Template',
'_Test Payment Terms Template For Purchase Invoice').delete()
def _test_purchase_return_return_against_purchase_order(self):
actual_qty_0 = get_qty_after_transaction()
from erpnext.buying.doctype.purchase_order.test_purchase_order \
import test_records as purchase_order_test_records
from erpnext.buying.doctype.purchase_order.purchase_order import \
make_purchase_receipt, make_purchase_invoice
# submit purchase receipt
po = frappe.copy_doc(purchase_order_test_records[0])
po.transaction_date = nowdate()
po.is_subcontracted = None
po.get("items")[0].item_code = "_Test Item"
po.get("items")[0].rate = 50
po.insert()
po.submit()
pr_doc = make_purchase_receipt(po.name)
pr = frappe.get_doc(pr_doc)
pr.posting_date = po.transaction_date
pr.insert()
pr.submit()
actual_qty_1 = get_qty_after_transaction()
self.assertEquals(actual_qty_0 + 10, actual_qty_1)
pi_doc = make_purchase_invoice(po.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Payable - _TC"
for d in pi.get("items"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("taxes"):
d.cost_center = "_Test Cost Center - _TC"
pi.run_method("calculate_taxes_and_totals")
pi.bill_no = "NA"
pi.insert()
pi.submit()
# submit purchase return
se = make_stock_entry(item_code="_Test Item",
source="_Test Warehouse - _TC",
qty=5,
purpose="Purchase Return",
purchase_receipt_no=pr.name)
actual_qty_2 = get_qty_after_transaction()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
return se, pr.name
def test_purchase_invoice_explicit_block(self):
pi = make_purchase_invoice()
pi.block_invoice()
self.assertEqual(pi.on_hold, 1)
pi.unblock_invoice()
self.assertEqual(pi.on_hold, 0)
def work():
frappe.set_user(frappe.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0] != "Total"]))[:random.randint(1, 5)]:
try:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = frappe.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(
frappe.get_cached_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0] != "Total"]))[:random.randint(1, 5)]:
try:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = frappe.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.4:
# make payment request against sales invoice
sales_invoice_name = get_random(
"Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = frappe.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(
make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
make_pos_invoice()
def test_purchase_receipt_return(self):
self._clear_stock_account_balance()
actual_qty_0 = self._get_actual_qty()
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import (
test_records as purchase_receipt_test_records,
)
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
# submit purchase receipt
pr = frappe.copy_doc(purchase_receipt_test_records[0])
pr.insert()
pr.submit()
actual_qty_1 = self._get_actual_qty()
self.assertEquals(actual_qty_0 + 5, actual_qty_1)
pi_doc = make_purchase_invoice(pr.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Supplier - _TC"
for d in pi.get("entries"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("other_charges"):
d.cost_center = "_Test Cost Center - _TC"
pi.run_method("calculate_taxes_and_totals")
pi.bill_no = "NA"
pi.insert()
pi.submit()
# submit purchase return
se = frappe.copy_doc(test_records[0])
se.purpose = "Purchase Return"
se.purchase_receipt_no = pr.name
se.posting_date = "2013-03-01"
se.fiscal_year = "_Test Fiscal Year 2013"
se.get("mtn_details")[0].qty = se.get("mtn_details")[0].transfer_qty = 5
se.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC"
se.insert()
se.submit()
actual_qty_2 = self._get_actual_qty()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
frappe.db.set_default("company", self.old_default_company)
return se, pr.name
def test_purchase_receipt_return(self):
self._clear_stock_account_balance()
actual_qty_0 = self._get_actual_qty()
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt \
import test_records as purchase_receipt_test_records
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
# submit purchase receipt
pr = frappe.copy_doc(purchase_receipt_test_records[0])
pr.insert()
pr.submit()
actual_qty_1 = self._get_actual_qty()
self.assertEquals(actual_qty_0 + 5, actual_qty_1)
pi_doc = make_purchase_invoice(pr.name)
pi = frappe.get_doc(pi_doc)
pi.posting_date = pr.posting_date
pi.credit_to = "_Test Supplier - _TC"
for d in pi.get("entries"):
d.expense_account = "_Test Account Cost for Goods Sold - _TC"
d.cost_center = "_Test Cost Center - _TC"
for d in pi.get("other_charges"):
d.cost_center = "_Test Cost Center - _TC"
pi.run_method("calculate_taxes_and_totals")
pi.bill_no = "NA"
pi.insert()
pi.submit()
# submit purchase return
se = frappe.copy_doc(test_records[0])
se.purpose = "Purchase Return"
se.purchase_receipt_no = pr.name
se.posting_date = "2013-03-01"
se.fiscal_year = "_Test Fiscal Year 2013"
se.get("mtn_details")[0].qty = se.get(
"mtn_details")[0].transfer_qty = 5
se.get("mtn_details")[0].s_warehouse = "_Test Warehouse - _TC"
se.insert()
se.submit()
actual_qty_2 = self._get_actual_qty()
self.assertEquals(actual_qty_1 - 5, actual_qty_2)
frappe.db.set_default("company", self.old_default_company)
return se, pr.name
def test_purchase_invoice_temporary_blocked(self):
pi = make_purchase_invoice(do_not_save=True)
pi.release_date = add_days(nowdate(), 10)
pi.save()
pi.submit()
pe = get_payment_entry('Purchase Invoice',
dn=pi.name,
bank_account="_Test Bank - _TC")
self.assertRaises(frappe.ValidationError, pe.save)
def work():
frappe.set_user(frappe.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = frappe.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(frappe.db.get_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = frappe.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.1:
#make payment request against sales invoice
sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = frappe.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
make_pos_invoice()
def run_accounts(current_date):
if can_make("Sales Invoice"):
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Sales Invoice")]:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = current_date
si.fiscal_year = cstr(current_date.year)
for d in si.get("entries"):
if not d.income_account:
d.income_account = "Sales - {}".format(company_abbr)
si.insert()
si.submit()
frappe.db.commit()
if can_make("Purchase Invoice"):
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Invoice")]:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = current_date
pi.fiscal_year = cstr(current_date.year)
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
if can_make("Payment Received"):
from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_sales_invoice
report = "Accounts Receivable"
for si in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Sales Invoice"]))[:how_many("Payment Received")]:
jv = frappe.get_doc(get_payment_entry_from_sales_invoice(si))
jv.posting_date = current_date
jv.cheque_no = random_string(6)
jv.cheque_date = current_date
jv.fiscal_year = cstr(current_date.year)
jv.insert()
jv.submit()
frappe.db.commit()
if can_make("Payment Made"):
from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_purchase_invoice
report = "Accounts Payable"
for pi in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Purchase Invoice"]))[:how_many("Payment Made")]:
jv = frappe.get_doc(get_payment_entry_from_purchase_invoice(pi))
jv.posting_date = current_date
jv.cheque_no = random_string(6)
jv.cheque_date = current_date
jv.fiscal_year = cstr(current_date.year)
jv.insert()
jv.submit()
frappe.db.commit()
def test_make_purchase_invoice(self):
pr = make_purchase_receipt(do_not_save=True)
self.assertRaises(frappe.ValidationError, make_purchase_invoice, pr.name)
pr.submit()
pi = make_purchase_invoice(pr.name)
self.assertEquals(pi.doctype, "Purchase Invoice")
self.assertEquals(len(pi.get("items")), len(pr.get("items")))
# modify rate
pi.get("items")[0].rate = 200
self.assertRaises(frappe.ValidationError, frappe.get_doc(pi).submit)
def test_make_purchase_invoice_from_pr_for_returned_qty(self): from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order, create_pr_against_po po = create_purchase_order() pr = create_pr_against_po(po.name) pr1 = make_purchase_receipt(is_return=1, return_against=pr.name, qty=-1, do_not_submit=True) pr1.items[0].purchase_order = po.name pr1.items[0].purchase_order_item = po.items[0].name pr1.submit() pi = make_purchase_invoice(pr.name) self.assertEquals(pi.items[0].qty, 3)
def test_make_purchase_invoice_from_pr_for_returned_qty(self): from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order, create_pr_against_po po = create_purchase_order() pr = create_pr_against_po(po.name) pr1 = make_purchase_receipt(is_return=1, return_against=pr.name, qty=-1, do_not_submit=True) pr1.items[0].purchase_order = po.name pr1.items[0].purchase_order_item = po.items[0].name pr1.submit() pi = make_purchase_invoice(pr.name) self.assertEquals(pi.items[0].qty, 3)
def test_pr_billing_status(self):
# PO -> PR1 -> PI and PO -> PI and PO -> PR2
from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
from erpnext.buying.doctype.purchase_order.purchase_order \
import make_purchase_receipt, make_purchase_invoice as make_purchase_invoice_from_po
po = create_purchase_order()
pr1 = make_purchase_receipt(po.name)
pr1.posting_date = today()
pr1.posting_time = "10:00"
pr1.get("items")[0].received_qty = 2
pr1.get("items")[0].qty = 2
pr1.submit()
pi1 = make_purchase_invoice(pr1.name)
pi1.submit()
pr1.load_from_db()
self.assertEqual(pr1.per_billed, 100)
pi2 = make_purchase_invoice_from_po(po.name)
pi2.get("items")[0].qty = 4
pi2.submit()
pr2 = make_purchase_receipt(po.name)
pr2.posting_date = today()
pr2.posting_time = "08:00"
pr2.get("items")[0].received_qty = 5
pr2.get("items")[0].qty = 5
pr2.submit()
pr1.load_from_db()
self.assertEqual(pr1.get("items")[0].billed_amt, 1000)
self.assertEqual(pr1.per_billed, 100)
self.assertEqual(pr1.status, "Completed")
pr2.load_from_db()
self.assertEqual(pr2.get("items")[0].billed_amt, 2000)
self.assertEqual(pr2.per_billed, 80)
self.assertEqual(pr2.status, "To Bill")
pr2.cancel()
pi2.reload()
pi2.cancel()
pi1.reload()
pi1.cancel()
pr1.reload()
pr1.cancel()
po.reload()
po.cancel()
def run_accounts(current_date):
if can_make("Sales Invoice"):
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Sales Invoice")]:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = current_date
si.fiscal_year = cstr(current_date.year)
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(settings.company_abbr)
si.insert()
si.submit()
frappe.db.commit()
if can_make("Purchase Invoice"):
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Invoice")]:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = current_date
pi.fiscal_year = cstr(current_date.year)
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
if can_make("Payment Received"):
from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_from_sales_invoice
report = "Accounts Receivable"
for si in list(set([r[3] for r in query_report.run(report, {"report_date": current_date })["result"] if r[2]=="Sales Invoice"]))[:how_many("Payment Received")]:
jv = frappe.get_doc(get_payment_entry_from_sales_invoice(si))
jv.posting_date = current_date
jv.cheque_no = random_string(6)
jv.cheque_date = current_date
jv.insert()
jv.submit()
frappe.db.commit()
if can_make("Payment Made"):
from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_from_purchase_invoice
report = "Accounts Payable"
for pi in list(set([r[3] for r in query_report.run(report, {"report_date": current_date })["result"] if r[2]=="Purchase Invoice"]))[:how_many("Payment Made")]:
jv = frappe.get_doc(get_payment_entry_from_purchase_invoice(pi))
jv.posting_date = current_date
jv.cheque_no = random_string(6)
jv.cheque_date = current_date
jv.insert()
jv.submit()
frappe.db.commit()
def test_duplicate_due_date_in_terms(self):
pi = make_purchase_invoice(do_not_save=1)
pi.append(
'payment_schedule',
dict(due_date='2017-01-01',
invoice_portion=50.00,
payment_amount=50))
pi.append(
'payment_schedule',
dict(due_date='2017-01-01',
invoice_portion=50.00,
payment_amount=50))
self.assertRaises(frappe.ValidationError, pi.insert)
def test_make_purchase_invoice_from_dn_with_returned_qty_against_dn(self):
pr1 = make_purchase_receipt(qty=8, do_not_submit=True)
pr1.append("items", {
"item_code": "_Test Item",
"warehouse": "_Test Warehouse - _TC",
"qty": 1,
"received_qty": 1,
"rate": 100,
"conversion_factor": 1.0,
})
pr1.submit()
pi1 = make_purchase_invoice(pr1.name)
pi1.items[0].qty = 4
pi1.items.pop(1)
pi1.save()
pi1.submit()
make_purchase_receipt(is_return=1, return_against=pr1.name, qty=-2)
pi2 = make_purchase_invoice(pr1.name)
self.assertEquals(pi2.items[0].qty, 2)
self.assertEquals(pi2.items[1].qty, 1)
def test_purchase_invoice_for_blocked_supplier_payment(self):
supplier = frappe.get_doc('Supplier', '_Test Supplier')
supplier.on_hold = 1
supplier.hold_type = 'Payments'
supplier.save()
pi = make_purchase_invoice()
self.assertRaises(frappe.ValidationError,
get_payment_entry,
dt='Purchase Invoice',
dn=pi.name,
bank_account="_Test Bank - _TC")
supplier.on_hold = 0
supplier.save()
def run_accounts(current_date):
if can_make("Sales Invoice"):
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Sales Invoice")]:
si = webnotes.bean(make_sales_invoice(so))
si.doc.posting_date = current_date
si.insert()
si.submit()
webnotes.conn.commit()
if can_make("Purchase Invoice"):
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Invoice")]:
pi = webnotes.bean(make_purchase_invoice(pr))
pi.doc.posting_date = current_date
pi.doc.bill_no = random_string(6)
pi.insert()
pi.submit()
webnotes.conn.commit()
if can_make("Payment Received"):
from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_sales_invoice
report = "Accounts Receivable"
for si in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Sales Invoice"]))[:how_many("Payment Received")]:
jv = webnotes.bean(get_payment_entry_from_sales_invoice(si))
jv.doc.posting_date = current_date
jv.doc.cheque_no = random_string(6)
jv.doc.cheque_date = current_date
jv.insert()
jv.submit()
webnotes.conn.commit()
if can_make("Payment Made"):
from erpnext.accounts.doctype.journal_voucher.journal_voucher import get_payment_entry_from_purchase_invoice
report = "Accounts Payable"
for pi in list(set([r[4] for r in query_report.run(report, {"report_date": current_date })["result"] if r[3]=="Purchase Invoice"]))[:how_many("Payment Made")]:
jv = webnotes.bean(get_payment_entry_from_purchase_invoice(pi))
jv.doc.posting_date = current_date
jv.doc.cheque_no = random_string(6)
jv.doc.cheque_date = current_date
jv.insert()
jv.submit()
webnotes.conn.commit()
def test_pr_billing_status(self):
# PO -> PR1 -> PI and PO -> PI and PO -> PR2
from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
from erpnext.buying.doctype.purchase_order.purchase_order import (
make_purchase_receipt,
make_purchase_invoice as make_purchase_invoice_from_po,
)
po = create_purchase_order()
pr1 = make_purchase_receipt(po.name)
pr1.posting_date = today()
pr1.posting_time = "10:00"
pr1.get("items")[0].received_qty = 2
pr1.get("items")[0].qty = 2
pr1.submit()
pi1 = make_purchase_invoice(pr1.name)
pi1.submit()
pr1.load_from_db()
self.assertEqual(pr1.per_billed, 100)
pi2 = make_purchase_invoice_from_po(po.name)
pi2.get("items")[0].qty = 4
pi2.submit()
pr2 = make_purchase_receipt(po.name)
pr2.posting_date = today()
pr2.posting_time = "08:00"
pr2.get("items")[0].received_qty = 5
pr2.get("items")[0].qty = 5
pr2.submit()
pr1.load_from_db()
self.assertEqual(pr1.get("items")[0].billed_amt, 1000)
self.assertEqual(pr1.per_billed, 100)
self.assertEqual(pr1.status, "Completed")
self.assertEqual(pr2.get("items")[0].billed_amt, 2000)
self.assertEqual(pr2.per_billed, 80)
self.assertEqual(pr2.status, "To Bill")
def test_make_purchase_invoice(self):
self._clear_stock_account_balance()
set_perpetual_inventory(0)
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
pr = frappe.bean(copy=test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_purchase_invoice,
pr.doc.name)
pr = frappe.bean("Purchase Receipt", pr.doc.name)
pr.submit()
pi = make_purchase_invoice(pr.doc.name)
self.assertEquals(pi[0]["doctype"], "Purchase Invoice")
self.assertEquals(len(pi), len(pr.doclist))
# modify rate
pi[1].rate = 200
self.assertRaises(frappe.ValidationError, frappe.bean(pi).submit)
def test_make_purchase_invoice(self):
self._clear_stock_account_balance()
set_perpetual_inventory(0)
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
pr = frappe.copy_doc(test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_purchase_invoice,
pr.name)
pr = frappe.get_doc("Purchase Receipt", pr.name)
pr.submit()
pi = make_purchase_invoice(pr.name)
self.assertEquals(pi.doctype, "Purchase Invoice")
self.assertEquals(len(pi.get("entries")), len(pr.get("purchase_receipt_details")))
# modify rate
pi.get("entries")[0].rate = 200
self.assertRaises(frappe.ValidationError, frappe.get_doc(pi).submit)
def test_make_purchase_invoice(self):
self._clear_stock_account_balance()
set_perpetual_inventory(0)
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import make_purchase_invoice
pr = frappe.copy_doc(test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_purchase_invoice,
pr.name)
pr = frappe.get_doc("Purchase Receipt", pr.name)
pr.submit()
pi = make_purchase_invoice(pr.name)
self.assertEquals(pi.doctype, "Purchase Invoice")
self.assertEquals(len(pi.get("items")), len(pr.get("items")))
# modify rate
pi.get("items")[0].rate = 200
self.assertRaises(frappe.ValidationError, frappe.get_doc(pi).submit)
def test_rejected_serial_no(self):
pi = make_purchase_invoice(
item_code="_Test Serialized Item With Series",
received_qty=2,
qty=1,
rejected_qty=1,
rate=500,
update_stock=1,
rejected_warehouse="_Test Rejected Warehouse - _TC")
self.assertEqual(
frappe.db.get_value("Serial No",
pi.get("items")[0].serial_no, "warehouse"),
pi.get("items")[0].warehouse)
self.assertEqual(
frappe.db.get_value("Serial No",
pi.get("items")[0].rejected_serial_no,
"warehouse"),
pi.get("items")[0].rejected_warehouse)
def test_payment_entry_unlink_against_purchase_invoice(self):
from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
unlink_payment_on_cancel_of_invoice(0)
pi_doc = make_purchase_invoice()
pe = get_payment_entry("Purchase Invoice",
pi_doc.name,
bank_account="_Test Bank - _TC")
pe.reference_no = "1"
pe.reference_date = nowdate()
pe.paid_from_account_currency = pi_doc.currency
pe.paid_to_account_currency = pi_doc.currency
pe.source_exchange_rate = 1
pe.target_exchange_rate = 1
pe.paid_amount = pi_doc.grand_total
pe.save(ignore_permissions=True)
pe.submit()
pi_doc = frappe.get_doc('Purchase Invoice', pi_doc.name)
self.assertRaises(frappe.LinkExistsError, pi_doc.cancel)
def test_purchase_invoice_for_blocked_supplier_payment_past_date(self):
# this test is meant to fail only if something fails in the try block
with self.assertRaises(Exception):
try:
supplier = frappe.get_doc('Supplier', '_Test Supplier')
supplier.on_hold = 1
supplier.hold_type = 'Payments'
supplier.release_date = '2018-03-01'
supplier.save()
pi = make_purchase_invoice()
get_payment_entry('Purchase Invoice',
dn=pi.name,
bank_account="_Test Bank - _TC")
supplier.on_hold = 0
supplier.save()
except:
pass
else:
raise Exception
def test_subcontracting_via_purchase_invoice(self):
from erpnext.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse 1 - _TC",
qty=100,
basic_rate=100)
make_stock_entry(item_code="_Test Item Home Desktop 100",
target="_Test Warehouse 1 - _TC",
qty=100,
basic_rate=100)
pi = make_purchase_invoice(item_code="_Test FG Item",
qty=10,
rate=500,
update_stock=1,
is_subcontracted="Yes")
self.assertEqual(len(pi.get("supplied_items")), 2)
rm_supp_cost = sum([d.amount for d in pi.get("supplied_items")])
self.assertEqual(pi.get("items")[0].rm_supp_cost, flt(rm_supp_cost, 2))
