def create_purchase_invoices(): pi = make_purchase_invoice( company="_Test Company GST", supplier = '_Test Registered Supplier', currency = 'INR', warehouse = 'Finished Goods - _GST', cost_center = 'Main - _GST', do_not_save=1, ) pi.eligibility_for_itc = "All Other ITC" pi.append("taxes", { "charge_type": "On Net Total", "account_head": "IGST - _GST", "cost_center": "Main - _GST", "description": "IGST @ 18.0", "rate": 18 }) pi.submit() pi1 = make_purchase_invoice( company="_Test Company GST", supplier = '_Test Registered Supplier', currency = 'INR', warehouse = 'Finished Goods - _GST', cost_center = 'Main - _GST', item = "Milk", do_not_save=1 ) pi1.submit()
def create_purchase_invoices(): pi = make_purchase_invoice( company="_Test Company GST", supplier='_Test Registered Supplier', currency='INR', warehouse='Finished Goods - _GST', cost_center='Main - _GST', expense_account='Cost of Goods Sold - _GST', do_not_save=1, ) pi.eligibility_for_itc = "All Other ITC" pi.append( "taxes", { "charge_type": "On Net Total", "account_head": "CGST - _GST", "cost_center": "Main - _GST", "description": "CGST @ 9.0", "rate": 9 }) pi.append( "taxes", { "charge_type": "On Net Total", "account_head": "SGST - _GST", "cost_center": "Main - _GST", "description": "SGST @ 9.0", "rate": 9 }) pi.submit() pi1 = make_purchase_invoice(company="_Test Company GST", supplier='_Test Registered Supplier', currency='INR', warehouse='Finished Goods - _GST', cost_center='Main - _GST', expense_account='Cost of Goods Sold - _GST', item="Milk", do_not_save=1) pi1.shipping_address = "_Test Supplier GST-1-Billing" pi1.save() pi1.submit() pi2 = make_purchase_invoice(company="_Test Company GST", customer='_Test Registered Supplier', currency='INR', item='Milk', warehouse='Finished Goods - _GST', expense_account='Cost of Goods Sold - _GST', cost_center='Main - _GST', rate=250, qty=1, do_not_save=1) pi2.submit()
def test_payment_terms_are_fetched_when_creating_purchase_invoice(self): from erpnext.accounts.doctype.payment_entry.test_payment_entry import ( create_payment_terms_template, ) from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice from erpnext.selling.doctype.sales_order.test_sales_order import ( automatically_fetch_payment_terms, compare_payment_schedules, ) automatically_fetch_payment_terms() po = create_purchase_order(qty=10, rate=100, do_not_save=1) create_payment_terms_template() po.payment_terms_template = "Test Receivable Template" po.submit() pi = make_purchase_invoice(qty=10, rate=100, do_not_save=1) pi.items[0].purchase_order = po.name pi.items[0].po_detail = po.items[0].name pi.insert() # self.assertEqual(po.payment_terms_template, pi.payment_terms_template) compare_payment_schedules(self, po, pi) automatically_fetch_payment_terms(enable=0)
def test_item_type_field_change(self): """Check if critical fields like `is_stock_item`, `has_batch_no` are not changed if transactions exist.""" from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry transaction_creators = [ lambda i: make_purchase_receipt(item_code=i), lambda i: make_purchase_invoice(item_code=i, update_stock=1), lambda i: make_stock_entry( item_code=i, qty=1, target="_Test Warehouse - _TC"), lambda i: create_delivery_note(item_code=i), ] properties = { "has_batch_no": 0, "allow_negative_stock": 1, "valuation_rate": 10 } for transaction_creator in transaction_creators: item = make_item(properties=properties) transaction = transaction_creator(item.name) item.has_batch_no = 1 self.assertRaises(frappe.ValidationError, item.save) transaction.cancel() # should be allowed now item.reload() item.has_batch_no = 1 item.save()
def create_purchase_invoices(): pi = make_purchase_invoice( company="_Test Company SA VAT", supplier="_Test SA Supplier", supplier_warehouse="Finished Goods - _TCSV", warehouse="Finished Goods - _TCSV", currency="ZAR", cost_center="Main - _TCSV", expense_account="Cost of Goods Sold - _TCSV", item="_Test SA VAT Item", qty=1, rate=100, uom="Nos", do_not_save=1, ) pi.append( "taxes", { "charge_type": "On Net Total", "account_head": "VAT - 15% - _TCSV", "cost_center": "Main - _TCSV", "description": "VAT 15% @ 15.0", "rate": 15.0, }, ) pi.submit()
def test_payment_entry_against_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() pi = make_purchase_invoice(credit_to="Creditors - _TC") pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "112222-2" pe.reference_date = nowdate() pe.paid_from = "_Test Bank - _TC" pe.paid_amount = pi.grand_total pe.insert() pe.submit() 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='Payment Entry' and voucher_no=%s order by account asc""", pe.name, as_dict=1) self.assertTrue(gl_entries) for gle in gl_entries: self.assertEqual(gle.cost_center, None)
def test_payment_against_purchase_invoice_to_check_status(self): pi = make_purchase_invoice(supplier="_Test Supplier USD", debit_to="_Test Payable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.source_exchange_rate = 50 pe.insert() pe.submit() outstanding_amount, status = frappe.db.get_value( "Purchase Invoice", pi.name, ["outstanding_amount", "status"]) self.assertEqual(flt(outstanding_amount), 0) self.assertEqual(status, 'Paid') pe.cancel() outstanding_amount, status = frappe.db.get_value( "Purchase Invoice", pi.name, ["outstanding_amount", "status"]) self.assertEqual(flt(outstanding_amount), 250) self.assertEqual(status, 'Unpaid')
def test_landed_cost_voucher_against_purchase_invoice(self): set_perpetual_inventory(1) pi = make_purchase_invoice(update_stock=1, posting_date=frappe.utils.nowdate(), posting_time=frappe.utils.nowtime()) last_sle = frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC" }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1) submit_landed_cost_voucher("Purchase Invoice", pi.name) pi_lc_value = frappe.db.get_value("Purchase Invoice Item", {"parent": pi.name}, "landed_cost_voucher_amount") self.assertEqual(pi_lc_value, 50.0) last_sle_after_landed_cost = frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC" }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1) self.assertEqual(last_sle.qty_after_transaction, last_sle_after_landed_cost.qty_after_transaction) self.assertEqual( last_sle_after_landed_cost.stock_value - last_sle.stock_value, 50.0) gl_entries = get_gl_entries("Purchase Invoice", pi.name) self.assertTrue(gl_entries) stock_in_hand_account = get_inventory_account( pi.company, pi.get("items")[0].warehouse) expected_values = { stock_in_hand_account: [300.0, 0.0], "Creditors - _TC": [0.0, 250.0], "Expenses Included In Valuation - _TC": [0.0, 50.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 create_purchase_invoices(): pi = make_purchase_invoice( company="_Test Company UAE VAT", supplier="_Test UAE Supplier", supplier_warehouse="_Test UAE VAT Supplier Warehouse - _TCUV", warehouse="_Test UAE VAT Supplier Warehouse - _TCUV", currency="AED", cost_center="Main - _TCUV", expense_account="Cost of Goods Sold - _TCUV", item="_Test UAE VAT Item", do_not_save=1, uom="Nos", ) pi.append( "taxes", { "charge_type": "On Net Total", "account_head": "VAT 5% - _TCUV", "cost_center": "Main - _TCUV", "description": "VAT 5% @ 5.0", "rate": 5.0, }, ) pi.recoverable_standard_rated_expenses = 1 pi.submit()
def create_batch(item_code, rate, create_item_price_for_batch): pi = make_purchase_invoice(company="_Test Company", warehouse= "Stores - _TC", cost_center = "Main - _TC", update_stock=1, expense_account ="_Test Account Cost for Goods Sold - _TC", item_code=item_code) batch = frappe.db.get_value('Batch', {'item': item_code, 'reference_name': pi.name}) if not create_item_price_for_batch: create_price_list_for_batch(item_code, None, rate) else: create_price_list_for_batch(item_code, batch, rate) return batch
def test_payment_entry_for_blocked_supplier_payments(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 test_payment_entry_for_blocked_supplier_payments(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 test_landed_cost_voucher_against_purchase_invoice(self): set_perpetual_inventory(1) pi = make_purchase_invoice(update_stock=1, posting_date=frappe.utils.nowdate(), posting_time=frappe.utils.nowtime()) last_sle = frappe.db.get_value("Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC" }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1) submit_landed_cost_voucher("Purchase Invoice", pi.name) pi_lc_value = frappe.db.get_value("Purchase Invoice Item", {"parent": pi.name}, "landed_cost_voucher_amount") self.assertEquals(pi_lc_value, 50.0) last_sle_after_landed_cost = frappe.db.get_value("Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC" }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1) self.assertEqual(last_sle.qty_after_transaction, last_sle_after_landed_cost.qty_after_transaction) self.assertEqual(last_sle_after_landed_cost.stock_value - last_sle.stock_value, 50.0) gl_entries = get_gl_entries("Purchase Invoice", pi.name) self.assertTrue(gl_entries) stock_in_hand_account = get_inventory_account(pi.company, pi.get("items")[0].warehouse) expected_values = { stock_in_hand_account: [300.0, 0.0], "Creditors - _TC": [0.0, 250.0], "Expenses Included In Valuation - _TC": [0.0, 50.0] } for gle in gl_entries: self.assertEquals(expected_values[gle.account][0], gle.debit) self.assertEquals(expected_values[gle.account][1], gle.credit) set_perpetual_inventory(0)
def test_payment_order_creation_against_payment_entry(self): purchase_invoice = make_purchase_invoice() payment_entry = get_payment_entry("Purchase Invoice", purchase_invoice.name, bank_account="_Test Bank - _TC") payment_entry.reference_no = "_Test_Payment_Order" payment_entry.reference_date = getdate() payment_entry.party_bank_account = "Checking Account - Citi Bank" payment_entry.insert() payment_entry.submit() doc = create_payment_order_against_payment_entry(payment_entry, "Payment Entry") reference_doc = doc.get("references")[0] self.assertEquals(reference_doc.reference_name, payment_entry.name) self.assertEquals(reference_doc.reference_doctype, "Payment Entry") self.assertEquals(reference_doc.supplier, "_Test Supplier") self.assertEquals(reference_doc.amount, 250)
def test_payment_entry_against_pi(self): pi = make_purchase_invoice(supplier="_Test Supplier USD", debit_to="_Test Payable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.source_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Payable USD - _TC", 12500, 0, pi.name], ["_Test Bank USD - _TC", 0, 12500, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", pi.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_against_pi(self): pi = make_purchase_invoice(supplier="_Test Supplier USD", debit_to="_Test Payable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.source_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Payable USD - _TC", 12500, 0, pi.name], ["_Test Bank USD - _TC", 0, 12500, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", pi.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_for_blocked_supplier_payments_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', pi.name, bank_account="_Test Bank - _TC") supplier.on_hold = 0 supplier.save() except: pass else: raise Exception
def test_payment_entry_for_blocked_supplier_payments_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', pi.name, bank_account="_Test Bank - _TC") supplier.on_hold = 0 supplier.save() except: pass else: raise Exception
def test_payment_entry_against_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() pi = make_purchase_invoice(credit_to="Creditors - _TC") pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "112222-2" pe.reference_date = nowdate() pe.paid_from = "_Test Bank - _TC" pe.paid_amount = pi.grand_total pe.insert() pe.submit() 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='Payment Entry' and voucher_no=%s order by account asc""", pe.name, as_dict=1) self.assertTrue(gl_entries) for gle in gl_entries: self.assertEqual(gle.cost_center, None)
def test_landed_cost_voucher_against_purchase_invoice(self): pi = make_purchase_invoice( update_stock=1, posting_date=frappe.utils.nowdate(), posting_time=frappe.utils.nowtime(), cash_bank_account="Cash - TCP1", company="_Test Company with perpetual inventory", supplier_warehouse="Work In Progress - TCP1", warehouse="Stores - TCP1", cost_center="Main - TCP1", expense_account="_Test Account Cost for Goods Sold - TCP1", ) last_sle = frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "Stores - TCP1", }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1, ) create_landed_cost_voucher("Purchase Invoice", pi.name, pi.company) pi_lc_value = frappe.db.get_value("Purchase Invoice Item", {"parent": pi.name}, "landed_cost_voucher_amount") self.assertEqual(pi_lc_value, 50.0) last_sle_after_landed_cost = frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": pi.doctype, "voucher_no": pi.name, "item_code": "_Test Item", "warehouse": "Stores - TCP1", }, fieldname=["qty_after_transaction", "stock_value"], as_dict=1, ) self.assertEqual(last_sle.qty_after_transaction, last_sle_after_landed_cost.qty_after_transaction) self.assertEqual( last_sle_after_landed_cost.stock_value - last_sle.stock_value, 50.0) gl_entries = get_gl_entries("Purchase Invoice", pi.name) self.assertTrue(gl_entries) stock_in_hand_account = get_inventory_account( pi.company, pi.get("items")[0].warehouse) expected_values = { stock_in_hand_account: [300.0, 0.0], "Creditors - TCP1": [0.0, 250.0], "Expenses Included In Valuation - TCP1": [0.0, 50.0], } for gle in gl_entries: if not gle.get("is_cancelled"): self.assertEqual(expected_values[gle.account][0], gle.debit) self.assertEqual(expected_values[gle.account][1], gle.credit)
def create_asset_repair(**args): from erpnext.accounts.doctype.purchase_invoice.test_purchase_invoice import make_purchase_invoice from erpnext.stock.doctype.warehouse.test_warehouse import create_warehouse args = frappe._dict(args) if args.asset: asset = args.asset else: asset = create_asset(is_existing_asset=1, submit=1) asset_repair = frappe.new_doc("Asset Repair") asset_repair.update({ "asset": asset.name, "asset_name": asset.asset_name, "failure_date": nowdate(), "description": "Test Description", "repair_cost": 0, "company": asset.company }) if args.stock_consumption: asset_repair.stock_consumption = 1 asset_repair.warehouse = create_warehouse("Test Warehouse", company=asset.company) asset_repair.append( "stock_items", { "item": args.item or args.item_code or "_Test Item", "valuation_rate": args.rate if args.get("rate") is not None else 100, "consumed_quantity": args.qty or 1 }) asset_repair.insert(ignore_if_duplicate=True) if args.submit: asset_repair.repair_status = "Completed" asset_repair.cost_center = "_Test Cost Center - _TC" if args.stock_consumption: stock_entry = frappe.get_doc({ "doctype": "Stock Entry", "stock_entry_type": "Material Receipt", "company": asset.company }) stock_entry.append( 'items', { "t_warehouse": asset_repair.warehouse, "item_code": asset_repair.stock_items[0].item, "qty": asset_repair.stock_items[0].consumed_quantity }) stock_entry.submit() if args.capitalize_repair_cost: asset_repair.capitalize_repair_cost = 1 asset_repair.repair_cost = 1000 if asset.calculate_depreciation: asset_repair.increase_in_asset_life = 12 asset_repair.purchase_invoice = make_purchase_invoice().name asset_repair.submit() return asset_repair
def add_payments(): if frappe.flags.test_payments_created: return frappe.set_user("Administrator") try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Conrad Electronic" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Conrad Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Mr G" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Nov 18" pe.reference_date = "2018-11-01" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass try: frappe.get_doc({ "doctype": "Customer", "customer_group":"All Customer Groups", "customer_type": "Company", "customer_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.insert() pe.submit() si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Customer", "customer_group":"All Customer Groups", "customer_type": "Company", "customer_name": "Fayva" }).insert() except frappe.DuplicateEntryError: pass si = create_sales_invoice(customer="Fayva", qty=1, rate=109080) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Fayva Oct 18" pe.reference_date = "2018-10-29" pe.insert() pe.submit() company = frappe.db.get_single_value('Global Defaults', 'default_company') frappe.get_doc({ "doctype": "Mode of Payment", "name": "Cash" }).append("accounts", { "company": company, "default_account": "_Test Bank - _TC" }).save() si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_submit=1) si.is_pos = 1 si.append("payments", { "mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 109080 }) si.save() si.submit() frappe.flags.test_payments_created = True
def test_deferred_expense(self): self.clear_old_entries() # created deferred expense accounts, if not found deferred_expense_account = create_account( account_name="Deferred Expense", parent_account="Current Assets - _CD", company="_Test Company DR", ) acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings") acc_settings.book_deferred_entries_based_on = "Months" acc_settings.save() supplier = create_supplier(supplier_name="_Test Furniture Supplier", supplier_group="Local", supplier_type="Company") supplier.save() item = create_item( "_Test Office Desk", is_stock_item=0, warehouse="All Warehouses - _CD", company="_Test Company DR", ) item.enable_deferred_expense = 1 item.deferred_expense_account = deferred_expense_account item.no_of_months_exp = 3 item.save() pi = make_purchase_invoice( item=item.name, company="_Test Company DR", supplier="_Test Furniture Supplier", is_return=False, update_stock=False, posting_date=frappe.utils.datetime.date(2021, 5, 1), parent_cost_center="Main - _CD", cost_center="Main - _CD", do_not_save=True, rate=300, price_list_rate=300, warehouse="All Warehouses - _CD", qty=1, ) pi.set_posting_time = True pi.items[0].enable_deferred_expense = 1 pi.items[0].service_start_date = "2021-05-01" pi.items[0].service_end_date = "2021-08-01" pi.items[0].deferred_expense_account = deferred_expense_account pi.items[0].expense_account = "Office Maintenance Expenses - _CD" pi.save() pi.submit() pda = frappe.get_doc( dict( doctype="Process Deferred Accounting", posting_date=nowdate(), start_date="2021-05-01", end_date="2021-08-01", type="Expense", company="_Test Company DR", )) pda.insert() pda.submit() # execute report fiscal_year = frappe.get_doc( "Fiscal Year", frappe.defaults.get_user_default("fiscal_year")) self.filters = frappe._dict({ "company": frappe.defaults.get_user_default("Company"), "filter_based_on": "Date Range", "period_start_date": "2021-05-01", "period_end_date": "2021-08-01", "from_fiscal_year": fiscal_year.year, "to_fiscal_year": fiscal_year.year, "periodicity": "Monthly", "type": "Expense", "with_upcoming_postings": False, }) report = Deferred_Revenue_and_Expense_Report(filters=self.filters) report.run() expected = [ { "key": "may_2021", "total": -100.0, "actual": -100.0 }, { "key": "jun_2021", "total": -100.0, "actual": -100.0 }, { "key": "jul_2021", "total": -100.0, "actual": -100.0 }, { "key": "aug_2021", "total": 0, "actual": 0 }, ] self.assertEqual(report.period_total, expected)
def add_vouchers(): if frappe.flags.test_payments_created: return frappe.set_user("Administrator") try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Conrad Electronic" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Conrad Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Mr G" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Oct 18" pe.reference_date = "2018-10-24" pe.insert() pe.submit() pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700) pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Herr G Nov 18" pe.reference_date = "2018-11-01" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Supplier", "supplier_group":"All Supplier Groups", "supplier_type": "Company", "supplier_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass try: frappe.get_doc({ "doctype": "Customer", "customer_group":"All Customer Groups", "customer_type": "Company", "customer_name": "Poore Simon's" }).insert() except frappe.DuplicateEntryError: pass pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900, is_paid=1, do_not_save =1) pi.cash_bank_account = "_Test Bank - _TC" pi.insert() pi.submit() pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.paid_amount = 690 pe.received_amount = 690 pe.insert() pe.submit() si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Poore Simon's Oct 18" pe.reference_date = "2018-10-28" pe.insert() pe.submit() try: frappe.get_doc({ "doctype": "Customer", "customer_group":"All Customer Groups", "customer_type": "Company", "customer_name": "Fayva" }).insert() except frappe.DuplicateEntryError: pass si = create_sales_invoice(customer="Fayva", qty=1, rate=109080) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "Fayva Oct 18" pe.reference_date = "2018-10-29" pe.insert() pe.submit() mode_of_payment = frappe.get_doc({ "doctype": "Mode of Payment", "name": "Cash" }) if not frappe.db.get_value('Mode of Payment Account', {'company': "_Test Company", 'parent': "Cash"}): mode_of_payment.append("accounts", { "company": "_Test Company", "default_account": "_Test Bank - _TC" }) mode_of_payment.save() si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_submit=1) si.is_pos = 1 si.append("payments", { "mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 109080 }) si.save() si.submit() frappe.flags.test_payments_created = True
def test_asset_cwip_toggling_cases(self): cwip = frappe.db.get_value("Asset Category", "Computers", "enable_cwip_accounting") name = frappe.db.get_value("Asset Category Account", filters={"parent": "Computers"}, fieldname=["name"]) cwip_acc = "CWIP Account - _TC" frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", 0) frappe.db.set_value("Asset Category Account", name, "capital_work_in_progress_account", "") frappe.db.get_value("Company", "_Test Company", "capital_work_in_progress_account", "") # case 0 -- PI with cwip disable, Asset with cwip disabled, No cwip account set pi = make_purchase_invoice(item_code="Macbook Pro", qty=1, rate=200000.0, location="Test Location", update_stock=1) asset = frappe.db.get_value('Asset', { 'purchase_invoice': pi.name, 'docstatus': 0 }, 'name') asset_doc = frappe.get_doc('Asset', asset) asset_doc.available_for_use_date = nowdate() asset_doc.calculate_depreciation = 0 asset_doc.submit() gle = frappe.db.sql( """select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""", asset_doc.name) self.assertFalse(gle) # case 1 -- PR with cwip disabled, Asset with cwip enabled pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=200000.0, location="Test Location") frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", 1) frappe.db.set_value("Asset Category Account", name, "capital_work_in_progress_account", cwip_acc) asset = frappe.db.get_value('Asset', { 'purchase_receipt': pr.name, 'docstatus': 0 }, 'name') asset_doc = frappe.get_doc('Asset', asset) asset_doc.available_for_use_date = nowdate() asset_doc.calculate_depreciation = 0 asset_doc.submit() gle = frappe.db.sql( """select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""", asset_doc.name) self.assertFalse(gle) # case 2 -- PR with cwip enabled, Asset with cwip disabled pr = make_purchase_receipt(item_code="Macbook Pro", qty=1, rate=200000.0, location="Test Location") frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", 0) asset = frappe.db.get_value('Asset', { 'purchase_receipt': pr.name, 'docstatus': 0 }, 'name') asset_doc = frappe.get_doc('Asset', asset) asset_doc.available_for_use_date = nowdate() asset_doc.calculate_depreciation = 0 asset_doc.submit() gle = frappe.db.sql( """select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""", asset_doc.name) self.assertTrue(gle) # case 3 -- PI with cwip disabled, Asset with cwip enabled pi = make_purchase_invoice(item_code="Macbook Pro", qty=1, rate=200000.0, location="Test Location", update_stock=1) frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", 1) asset = frappe.db.get_value('Asset', { 'purchase_invoice': pi.name, 'docstatus': 0 }, 'name') asset_doc = frappe.get_doc('Asset', asset) asset_doc.available_for_use_date = nowdate() asset_doc.calculate_depreciation = 0 asset_doc.submit() gle = frappe.db.sql( """select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""", asset_doc.name) self.assertFalse(gle) # case 4 -- PI with cwip enabled, Asset with cwip disabled pi = make_purchase_invoice(item_code="Macbook Pro", qty=1, rate=200000.0, location="Test Location", update_stock=1) frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", 0) asset = frappe.db.get_value('Asset', { 'purchase_invoice': pi.name, 'docstatus': 0 }, 'name') asset_doc = frappe.get_doc('Asset', asset) asset_doc.available_for_use_date = nowdate() asset_doc.calculate_depreciation = 0 asset_doc.submit() gle = frappe.db.sql( """select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""", asset_doc.name) self.assertTrue(gle) frappe.db.set_value("Asset Category", "Computers", "enable_cwip_accounting", cwip) frappe.db.set_value("Asset Category Account", name, "capital_work_in_progress_account", cwip_acc) frappe.db.get_value("Company", "_Test Company", "capital_work_in_progress_account", cwip_acc)