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))