def test_multi_currency(self): customer = frappe.get_doc("Customer", "_Test Customer USD") create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) customer.party_account_currency = "EUR" self.assertRaises(InvalidCurrency, customer.save)
def _test_sales_invoice_return(self, item_code, delivered_qty, returned_qty): from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice si = create_sales_invoice(item_code=item_code, qty=delivered_qty) se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, do_not_save=True, ) self.assertRaises(NotUpdateStockError, se.insert) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=200, incoming_rate=100) # check currency available qty in bin actual_qty_0 = get_qty_after_transaction() # insert a pos invoice with update stock si = create_sales_invoice(update_stock=1, item_code=item_code, qty=5) # check available bin qty after invoice submission actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) # check if item is validated se = make_stock_entry( item_code="_Test Item Home Desktop 200", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, do_not_save=True, ) self.assertRaises(frappe.DoesNotExistError, se.insert) # try again se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", sales_invoice_no=si.name, ) # check if available qty is increased actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def make_credit_note(docname): create_sales_invoice(company="_Test Company 2", customer = '_Test Customer 2', currency = 'EUR', qty = -1, warehouse = 'Finished Goods - _TC2', debit_to = 'Debtors - _TC2', income_account = 'Sales - _TC2', expense_account = 'Cost of Goods Sold - _TC2', cost_center = '_Test Company 2 - _TC2', is_return = 1, return_against = docname)
def test_payment_against_negative_sales_invoice(self): pe1 = frappe.new_doc("Payment Entry") pe1.payment_type = "Pay" pe1.company = "_Test Company" pe1.party_type = "Customer" pe1.party = "_Test Customer" pe1.paid_from = "_Test Cash - _TC" pe1.paid_amount = 100 pe1.received_amount = 100 self.assertRaises(InvalidPaymentEntry, pe1.validate) si1 = create_sales_invoice() # create full payment entry against si1 pe2 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC") pe2.insert() pe2.submit() # create return entry against si1 create_sales_invoice(is_return=1, return_against=si1.name, qty=-1) si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount") self.assertEqual(si1_outstanding, -100) # pay more than outstanding against si1 pe3 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC") pe3.paid_amount = pe3.received_amount = 300 self.assertRaises(InvalidPaymentEntry, pe3.validate) # pay negative outstanding against si1 pe3.paid_to = "Debtors - _TC" pe3.paid_amount = pe3.received_amount = 100 pe3.insert() pe3.submit() expected_gle = dict((d[0], d) for d in [ ["Debtors - _TC", 100, 0, si1.name], ["_Test Cash - _TC", 0, 100, None] ]) self.validate_gl_entries(pe3.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0) pe3.cancel() self.assertFalse(self.get_gle(pe3.name)) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")) self.assertEqual(outstanding_amount, -100)
def test_pos_closing_voucher(self): old_user = frappe.session.user user = '******' test_user = frappe.get_doc('User', user) roles = ("Accounts Manager", "Accounts User", "Sales Manager") test_user.add_roles(*roles) frappe.set_user(user) pos_profile = make_pos_profile() pos_profile.append('applicable_for_users', { 'default': 1, 'user': user }) pos_profile.save() si1 = create_sales_invoice(is_pos=1, rate=3500, do_not_submit=1) si1.append('payments', { 'mode_of_payment': 'Cash', 'account': 'Cash - _TC', 'amount': 3500 }) si1.submit() si2 = create_sales_invoice(is_pos=1, rate=3200, do_not_submit=1) si2.append('payments', { 'mode_of_payment': 'Cash', 'account': 'Cash - _TC', 'amount': 3200 }) si2.submit() pcv_doc = create_pos_closing_voucher(user=user, pos_profile=pos_profile.name, collected_amount=6700) pcv_doc.get_closing_voucher_details() self.assertEqual(pcv_doc.total_quantity, 2) self.assertEqual(pcv_doc.net_total, 6700) payment = pcv_doc.payment_reconciliation[0] self.assertEqual(payment.mode_of_payment, 'Cash') si1.load_from_db() si1.cancel() si2.load_from_db() si2.cancel() test_user.load_from_db() test_user.remove_roles(*roles) frappe.set_user(old_user) frappe.db.sql("delete from `tabPOS Profile`")
def test_payment_entry_write_off_difference(self): si = create_sales_invoice() pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.received_amount = pe.paid_amount = 110 pe.insert() self.assertEqual(pe.unallocated_amount, 10) pe.received_amount = pe.paid_amount = 95 pe.append("deductions", { "account": "_Test Write Off - _TC", "cost_center": "_Test Cost Center - _TC", "amount": 5 }) pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["Debtors - _TC", 0, 100, si.name], ["_Test Cash - _TC", 95, 0, None], ["_Test Write Off - _TC", 5, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle)
def test_payment_entry_against_si_usd_to_inr(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, party_amount=20, bank_account="_Test Bank - _TC", bank_amount=900) pe.reference_no = "1" pe.reference_date = "2016-01-01" self.assertEqual(pe.difference_amount, 100) pe.append("deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": 100 }) pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 1000, si.name], ["_Test Bank - _TC", 900, 0, None], ["_Test Exchange Gain/Loss - _TC", 100.0, 0, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 80)
def test_payment_entry_exchange_gain_loss(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 55 pe.append("deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": -500 }) pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5500, 0, None], ["_Test Exchange Gain/Loss - _TC", 0, 500, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_against_si_usd_to_usd(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5000.0, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0) pe.cancel() self.assertFalse(self.get_gle(pe.name)) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 100)
def test_payment_entry(self): so_inr = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**", mute_email=1, submit_doc=1) jv = pr.set_as_paid() so_inr = frappe.get_doc("Sales Order", so_inr.name) self.assertEquals(so_inr.advance_paid, jv.total_debit) conversion_rate = get_exchange_rate("USD", "INR") si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=conversion_rate) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", mute_email=1, return_doc=1, payment_gateway="_Test Gateway - USD") jv = pr.set_as_paid() payment_gateway_details = get_gateway_details({"payment_gateway": "_Test Gateway - USD"}) self.assertEquals(jv.accounts[0].account, "_Test Receivable USD - _TC") self.assertEquals(jv.accounts[1].account, payment_gateway_details.payment_account)
def test_timesheet_billing_based_on_project(self): timesheet = make_timesheet("_T-Employee-0001", simulate=True, billable=1, project = '_Test Project', company='_Test Company') sales_invoice = create_sales_invoice(do_not_save=True) sales_invoice.project = '_Test Project' sales_invoice.submit() ts = frappe.get_doc('Timesheet', timesheet.name) self.assertEquals(ts.per_billed, 100) self.assertEquals(ts.time_logs[0].sales_invoice, sales_invoice.name)
def test_pricing_rule_with_margin_and_discount(self): frappe.delete_doc_if_exists('Pricing Rule', '_Test Pricing Rule') make_pricing_rule(selling=1, margin_type="Percentage", margin_rate_or_amount=10, discount_percentage=10) si = create_sales_invoice(do_not_save=True) si.items[0].price_list_rate = 1000 si.payment_schedule = [] si.insert(ignore_permissions=True) item = si.items[0] self.assertEquals(item.margin_rate_or_amount, 10) self.assertEquals(item.rate_with_margin, 1100) self.assertEqual(item.discount_percentage, 10) self.assertEquals(item.discount_amount, 110) self.assertEquals(item.rate, 990)
def test_payment_request_linkings(self): SO_INR = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Order") self.assertEquals(pr.reference_name, SO_INR.name) self.assertEquals(pr.currency, "INR") SI_USD = create_sales_invoice(currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Invoice") self.assertEquals(pr.reference_name, SI_USD.name) self.assertEquals(pr.currency, "USD")
def test_payment_request_linkings(self): so_inr = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Order") self.assertEquals(pr.reference_name, so_inr.name) self.assertEquals(pr.currency, "INR") conversion_rate = get_exchange_rate("USD", "INR") si_usd = create_sales_invoice(currency="USD", conversion_rate=conversion_rate) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Invoice") self.assertEquals(pr.reference_name, si_usd.name) self.assertEquals(pr.currency, "USD")
def test_payment_entry(self): SO_INR = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**", mute_email=1, submit_doc=1) jv = pr.set_as_paid() SO_INR = frappe.get_doc("Sales Order", SO_INR.name) self.assertEquals(SO_INR.advance_paid, jv.total_debit) SI_USD = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**", mute_email=1, return_doc=1, payemnt_gateway="_Test Gateway - USD") self.assertRaises(frappe.ValidationError, pr.save)
def test_gl_entries_in_base_currency(self): inv = create_sales_invoice(rate=200) inv_disc = create_invoice_discounting( [inv.name], accounts_receivable_credit=self.ar_credit, accounts_receivable_discounted=self.ar_discounted, accounts_receivable_unpaid=self.ar_unpaid, short_term_loan=self.short_term_loan, bank_charges_account=self.bank_charges_account, bank_account=self.bank_account) gle = get_gl_entries("Invoice Discounting", inv_disc.name) expected_gle = {inv.debit_to: [0.0, 200], self.ar_credit: [200, 0.0]} for i, gle in enumerate(gle): self.assertEqual([gle.debit, gle.credit], expected_gle.get(gle.account))
def test_timesheet_billing_based_on_project(self): emp = make_employee("*****@*****.**") project = frappe.get_value("Project", {"project_name": "_Test Project"}) timesheet = make_timesheet(emp, simulate=True, billable=1, project=project, company='_Test Company') sales_invoice = create_sales_invoice(do_not_save=True) sales_invoice.project = project sales_invoice.submit() ts = frappe.get_doc('Timesheet', timesheet.name) self.assertEqual(ts.per_billed, 100) self.assertEqual(ts.time_logs[0].sales_invoice, sales_invoice.name)
def test_pricing_rule_with_margin_and_discount(self): make_pricing_rule(selling=1, margin_type="Percentage", margin_rate_or_amount=10) si = create_sales_invoice(do_not_save=True) si.items[0].price_list_rate = 1000 si.insert(ignore_permissions=True) item = si.items[0] self.assertEquals(item.rate, 1100) self.assertEquals(item.margin_rate_or_amount, 10) # With discount item.discount_percentage = 10 si.save() item = si.items[0] self.assertEquals(item.rate, 990) self.assertEquals(item.discount_percentage, 10) frappe.db.sql("delete from `tabPricing Rule`")
def test_on_disbursed(self): inv = create_sales_invoice(rate=500) inv_disc = create_invoice_discounting( [inv.name], accounts_receivable_credit=self.ar_credit, accounts_receivable_discounted=self.ar_discounted, accounts_receivable_unpaid=self.ar_unpaid, short_term_loan=self.short_term_loan, bank_charges_account=self.bank_charges_account, bank_account=self.bank_account, bank_charges=100, ) je = inv_disc.create_disbursement_entry() self.assertEqual(je.accounts[0].account, self.bank_account) self.assertEqual( je.accounts[0].debit_in_account_currency, flt(inv_disc.total_amount) - flt(inv_disc.bank_charges), ) self.assertEqual(je.accounts[1].account, self.bank_charges_account) self.assertEqual(je.accounts[1].debit_in_account_currency, flt(inv_disc.bank_charges)) self.assertEqual(je.accounts[2].account, self.short_term_loan) self.assertEqual(je.accounts[2].credit_in_account_currency, flt(inv_disc.total_amount)) self.assertEqual(je.accounts[3].account, self.ar_discounted) self.assertEqual(je.accounts[3].debit_in_account_currency, flt(inv.outstanding_amount)) self.assertEqual(je.accounts[4].account, self.ar_credit) self.assertEqual(je.accounts[4].credit_in_account_currency, flt(inv.outstanding_amount)) je.posting_date = nowdate() je.submit() inv_disc.reload() self.assertEqual(inv_disc.status, "Disbursed") inv.reload() self.assertEqual(inv.outstanding_amount, 500)
def test_mandatory(self): si = create_sales_invoice(do_not_save=1) si.append( "items", { "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC", "qty": 1, "rate": 100, "income_account": "Sales - _TC", "expense_account": "Cost of Goods Sold - _TC", "cost_center": "_Test Cost Center - _TC", "location": "", }, ) si.save() self.assertRaises(frappe.ValidationError, si.submit)
def test_payment_request_linkings(self): so_inr = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**", payment_gateway_account="_Test Gateway - INR") self.assertEqual(pr.reference_doctype, "Sales Order") self.assertEqual(pr.reference_name, so_inr.name) self.assertEqual(pr.currency, "INR") conversion_rate = get_exchange_rate("USD", "INR") si_usd = create_sales_invoice(currency="USD", conversion_rate=conversion_rate) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", payment_gateway_account="_Test Gateway - USD") self.assertEqual(pr.reference_doctype, "Sales Invoice") self.assertEqual(pr.reference_name, si_usd.name) self.assertEqual(pr.currency, "USD")
def test_multiple_pricing_rules(self): make_pricing_rule(discount_percentage=20, selling=1, priority=1, apply_multiple_pricing_rules=1, title="_Test Pricing Rule 1") make_pricing_rule(discount_percentage=10, selling=1, title="_Test Pricing Rule 2", priority=2, apply_multiple_pricing_rules=1) si = create_sales_invoice(do_not_submit=True, customer="_Test Customer 1", qty=1) self.assertEqual(si.items[0].discount_percentage, 30) si.delete() frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 1") frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 2")
def test_creation_of_ledger_entry_on_submit(self): """test creation of gl entries on submission of document""" deferred_account = create_account( account_name="Deferred Revenue", parent_account="Current Liabilities - _TC", company="_Test Company", ) item = create_item("_Test Item for Deferred Accounting") item.enable_deferred_revenue = 1 item.deferred_revenue_account = deferred_account item.no_of_months = 12 item.save() si = create_sales_invoice( item=item.name, update_stock=0, posting_date="2019-01-10", do_not_submit=True ) si.items[0].enable_deferred_revenue = 1 si.items[0].service_start_date = "2019-01-10" si.items[0].service_end_date = "2019-03-15" si.items[0].deferred_revenue_account = deferred_account si.save() si.submit() process_deferred_accounting = doc = frappe.get_doc( dict( doctype="Process Deferred Accounting", posting_date="2019-01-01", start_date="2019-01-01", end_date="2019-01-31", type="Income", ) ) process_deferred_accounting.insert() process_deferred_accounting.submit() expected_gle = [ [deferred_account, 33.85, 0.0, "2019-01-31"], ["Sales - _TC", 0.0, 33.85, "2019-01-31"], ] check_gl_entries(self, si.name, expected_gle, "2019-01-10")
def test_payment_against_sales_invoice_to_check_status(self): si = create_sales_invoice(customer="_Test Customer", debit_to="_Test Receivable - _TC", currency="INR") pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.insert() pe.submit() outstanding_amount, status = frappe.db.get_value("Sales Invoice", si.name, ["outstanding_amount", "status"]) self.assertEqual(flt(outstanding_amount), 0) self.assertEqual(status, 'Paid') pe.cancel() outstanding_amount, status = frappe.db.get_value("Sales Invoice", si.name, ["outstanding_amount", "status"]) self.assertEqual(flt(outstanding_amount), 100) self.assertEqual(status, 'Unpaid')
def test_return_against_sales_order(self): so = make_sales_order() dn = create_dn_against_so(so.name, 6) so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 6) # Check delivered_qty after make_sales_invoice with update_stock checked si2 = make_sales_invoice(so.name) si2.set("update_stock", 1) si2.get("items")[0].qty = 3 si2.insert() si2.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 9) # Make return deliver note, sales invoice and check quantity from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-3, do_not_submit=True) dn1.items[0].against_sales_order = so.name dn1.items[0].so_detail = so.items[0].name dn1.submit() si1 = create_sales_invoice(is_return=1, return_against=si2.name, qty=-1, update_stock=1, do_not_submit=True) si1.items[0].sales_order = so.name si1.items[0].so_detail = so.items[0].name si1.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 5)
def test_payment_entry(self): frappe.db.set_value("Company", "_Test Company", "exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC") frappe.db.set_value("Company", "_Test Company", "write_off_account", "_Test Write Off - _TC") frappe.db.set_value("Company", "_Test Company", "cost_center", "_Test Cost Center - _TC") so_inr = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**", mute_email=1, submit_doc=1) pe = pr.set_as_paid() so_inr = frappe.get_doc("Sales Order", so_inr.name) self.assertEquals(so_inr.advance_paid, 1000) si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", mute_email=1, payment_gateway="_Test Gateway - USD", submit_doc=1) pe = pr.set_as_paid() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si_usd.name], [pr.payment_account, 6000.0, 0, None], ["_Test Exchange Gain/Loss - _TC", 0, 1000, None] ]) gl_entries = frappe.db.sql("""select account, debit, credit, against_voucher 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 i, gle in enumerate(gl_entries): self.assertEquals(expected_gle[gle.account][0], gle.account) self.assertEquals(expected_gle[gle.account][1], gle.debit) self.assertEquals(expected_gle[gle.account][2], gle.credit) self.assertEquals(expected_gle[gle.account][3], gle.against_voucher)
def make_sales_invoice(): frappe.set_user("Administrator") si = create_sales_invoice(company="_Test Company 2", customer = '_Test Customer 2', currency = 'EUR', warehouse = 'Finished Goods - _TC2', debit_to = 'Debtors - _TC2', income_account = 'Sales - _TC2', expense_account = 'Cost of Goods Sold - _TC2', cost_center = '_Test Company 2 - _TC2', do_not_save=1) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30)) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50)) si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20)) si.submit() return si.name
def test_on_close_after_loan_period(self): inv = create_sales_invoice(rate=600) inv_disc = create_invoice_discounting( [inv.name], accounts_receivable_credit=self.ar_credit, accounts_receivable_discounted=self.ar_discounted, accounts_receivable_unpaid=self.ar_unpaid, short_term_loan=self.short_term_loan, bank_charges_account=self.bank_charges_account, bank_account=self.bank_account, start=nowdate(), period=60, ) je1 = inv_disc.create_disbursement_entry() je1.posting_date = nowdate() je1.submit() je2 = inv_disc.close_loan() self.assertEqual(je2.accounts[0].account, self.short_term_loan) self.assertEqual(je2.accounts[0].debit_in_account_currency, flt(inv_disc.total_amount)) self.assertEqual(je2.accounts[1].account, self.bank_account) self.assertEqual(je2.accounts[1].credit_in_account_currency, flt(inv_disc.total_amount)) self.assertEqual(je2.accounts[2].account, self.ar_discounted) self.assertEqual(je2.accounts[2].credit_in_account_currency, flt(inv.outstanding_amount)) self.assertEqual(je2.accounts[3].account, self.ar_unpaid) self.assertEqual(je2.accounts[3].debit_in_account_currency, flt(inv.outstanding_amount)) je2.posting_date = nowdate() je2.submit() inv_disc.reload() self.assertEqual(inv_disc.status, "Settled")
def test_payment_entry(self): frappe.db.set_value("Company", "_Test Company", "exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC") frappe.db.set_value("Company", "_Test Company", "write_off_account", "_Test Write Off - _TC") frappe.db.set_value("Company", "_Test Company", "cost_center", "_Test Cost Center - _TC") so_inr = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**", mute_email=1, payment_gateway_account="_Test Gateway - INR", submit_doc=1, return_doc=1) pe = pr.set_as_paid() so_inr = frappe.get_doc("Sales Order", so_inr.name) self.assertEqual(so_inr.advance_paid, 1000) si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", mute_email=1, payment_gateway_account="_Test Gateway - USD", submit_doc=1, return_doc=1) pe = pr.set_as_paid() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si_usd.name], [pr.payment_account, 6290.0, 0, None], ["_Test Exchange Gain/Loss - _TC", 0, 1290, None] ]) gl_entries = frappe.db.sql("""select account, debit, credit, against_voucher 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 i, gle in enumerate(gl_entries): self.assertEqual(expected_gle[gle.account][0], gle.account) self.assertEqual(expected_gle[gle.account][1], gle.debit) self.assertEqual(expected_gle[gle.account][2], gle.credit) self.assertEqual(expected_gle[gle.account][3], gle.against_voucher)
def test_make_payment_before_after_period(self): #it has problem inv = create_sales_invoice(item_code="_Test Item Home Desktop 100", rate=700) inv_disc = create_invoice_discounting( [inv.name], accounts_receivable_credit=self.ar_credit, accounts_receivable_discounted=self.ar_discounted, accounts_receivable_unpaid=self.ar_unpaid, short_term_loan=self.short_term_loan, bank_charges_account=self.bank_charges_account, bank_account=self.bank_account, loan_start_date=add_days(nowdate(), -10), period=5) je = inv_disc.create_disbursement_entry() inv_disc.reload() je.posting_date = nowdate() je.submit() je = inv_disc.close_loan() inv_disc.reload() je.posting_date = nowdate() je.submit() je_on_payment = frappe.get_doc( get_payment_entry_against_invoice("Sales Invoice", inv.name)) je_on_payment.posting_date = nowdate() je_on_payment.cheque_no = "126981" je_on_payment.cheque_date = nowdate() je_on_payment.submit() self.assertEqual(je_on_payment.accounts[0].account, self.ar_unpaid) self.assertEqual(je_on_payment.accounts[0].credit_in_account_currency, flt(inv.outstanding_amount)) self.assertEqual(je_on_payment.accounts[1].account, self.bank_account) self.assertEqual(je_on_payment.accounts[1].debit_in_account_currency, flt(inv.outstanding_amount)) inv.reload() self.assertEqual(inv.outstanding_amount, 0)
def test_dimension_against_sales_invoice(self): si = create_sales_invoice(do_not_save=1) si.location = "Block 1" si.append("items", { "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC", "qty": 1, "rate": 100, "income_account": "Sales - _TC", "expense_account": "Cost of Goods Sold - _TC", "cost_center": "_Test Cost Center - _TC", "department": "_Test Department - _TC", "location": "Block 1" }) si.save() si.submit() gle = frappe.get_doc("GL Entry", {"voucher_no": si.name, "account": "Sales - _TC"}) self.assertEqual(gle.get('department'), "_Test Department - _TC")
def test_payment_entry_exchange_gain_loss(self): si = create_sales_invoice(customer="_Test Customer", debit_to="_Test Receivable - _TC", currency="INR") pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable - _TC", 0, 100, si.name], ["_Test Bank - _TC", 100, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_gst_rounding(self): gst_settings = frappe.get_doc("GST Settings") gst_settings.round_off_gst_values = 1 gst_settings.save() current_country = frappe.flags.country frappe.flags.country = "India" si = create_sales_invoice( company="_Test Company GST", customer="_Test GST Customer", currency="INR", warehouse="Finished Goods - _GST", debit_to="Debtors - _GST", income_account="Sales - _GST", expense_account="Cost of Goods Sold - _GST", cost_center="Main - _GST", rate=216, do_not_save=1, ) si.append( "taxes", { "charge_type": "On Net Total", "account_head": "Output Tax IGST - _GST", "cost_center": "Main - _GST", "description": "IGST @ 18.0", "rate": 18, }, ) si.save() # Check for 39 instead of 38.88 self.assertEqual(si.taxes[0].base_tax_amount_after_discount_amount, 39) frappe.flags.country = current_country gst_settings.round_off_gst_values = 1 gst_settings.save()
def test_remove_pricing_rule(self): item = make_item("Water Flask") make_item_price("Water Flask", "_Test Price List", 100) pricing_rule_record = { "doctype": "Pricing Rule", "title": "_Test Water Flask Rule", "apply_on": "Item Code", "price_or_product_discount": "Price", "items": [{ "item_code": "Water Flask", }], "selling": 1, "currency": "INR", "rate_or_discount": "Discount Percentage", "discount_percentage": 20, "company": "_Test Company", } rule = frappe.get_doc(pricing_rule_record) rule.insert() si = create_sales_invoice(do_not_save=True, item_code="Water Flask") si.selling_price_list = "_Test Price List" si.save() self.assertEqual(si.items[0].price_list_rate, 100) self.assertEqual(si.items[0].discount_percentage, 20) self.assertEqual(si.items[0].rate, 80) si.ignore_pricing_rule = 1 si.save() self.assertEqual(si.items[0].discount_percentage, 0) self.assertEqual(si.items[0].rate, 100) si.delete() rule.delete() frappe.get_doc("Item Price", {"item_code": "Water Flask"}).delete() item.delete()
def test_customer_credit_limit(self): from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice outstanding_amt = self.get_customer_outstanding_amount() credit_limit = get_credit_limit('_Test Customer', '_Test Company') if outstanding_amt <= 0.0: item_qty = int((abs(outstanding_amt) + 200) / 100) make_sales_order(qty=item_qty) if credit_limit == 0.0: frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', outstanding_amt - 50.0) # Sales Order so = make_sales_order(do_not_submit=True) self.assertRaises(frappe.ValidationError, so.submit) # Delivery Note dn = create_delivery_note(do_not_submit=True) self.assertRaises(frappe.ValidationError, dn.submit) # Sales Invoice si = create_sales_invoice(do_not_submit=True) self.assertRaises(frappe.ValidationError, si.submit) if credit_limit > outstanding_amt: frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', credit_limit) # Makes Sales invoice from Sales Order so.save(ignore_permissions=True) si = make_sales_invoice(so.name) si.save(ignore_permissions=True) self.assertRaises(frappe.ValidationError, make_sales_order)
def test_status(self): si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", mute_email=1, payment_gateway="_Test Gateway - USD", submit_doc=1, return_doc=1) pe = pr.create_payment_entry() pr.load_from_db() self.assertEqual(pr.status, 'Paid') pe.cancel() pr.load_from_db() self.assertEqual(pr.status, 'Requested')
def test_payment_entry_exchange_gain_loss(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 55 pe.append( "deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": -500 }) pe.save() self.assertEqual(pe.unallocated_amount, 0) self.assertEqual(pe.difference_amount, 0) pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5500, 0, None], ["_Test Exchange Gain/Loss - _TC", 0, 500, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt( frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0)
def test_payment_entry_against_payment_terms(self): si = create_sales_invoice(do_not_save=1, qty=1, rate=200) create_payment_terms_template() si.payment_terms_template = 'Test Receivable Template' si.append('taxes', { "charge_type": "On Net Total", "account_head": "_Test Account Service Tax - _TC", "cost_center": "_Test Cost Center - _TC", "description": "Service Tax", "rate": 18 }) si.save() si.submit() pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC") pe.submit() si.load_from_db() self.assertEqual(pe.references[0].payment_term, 'Basic Amount Receivable') self.assertEqual(pe.references[1].payment_term, 'Tax Receivable') self.assertEqual(si.payment_schedule[0].paid_amount, 200.0) self.assertEqual(si.payment_schedule[1].paid_amount, 36.0)
def test_payment_entry_against_sales_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() si = create_sales_invoice(debit_to="Debtors - _TC") pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC") pe.reference_no = "112211-2" pe.reference_date = nowdate() pe.paid_to = "_Test Bank - _TC" pe.paid_amount = si.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_customer_credit_limit(self): from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice outstanding_amt = self.get_customer_outstanding_amount() credit_limit = get_credit_limit('_Test Customer', '_Test Company') if outstanding_amt <= 0.0: item_qty = int((abs(outstanding_amt) + 200)/100) make_sales_order(qty=item_qty) if credit_limit == 0.0: frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', outstanding_amt - 50.0) # Sales Order so = make_sales_order(do_not_submit=True) self.assertRaises(frappe.ValidationError, so.submit) # Delivery Note dn = create_delivery_note(do_not_submit=True) self.assertRaises(frappe.ValidationError, dn.submit) # Sales Invoice si = create_sales_invoice(do_not_submit=True) self.assertRaises(frappe.ValidationError, si.submit) if credit_limit > outstanding_amt: frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', credit_limit) # Makes Sales invoice from Sales Order so.save(ignore_permissions=True) si = make_sales_invoice(so.name) si.save(ignore_permissions=True) self.assertRaises(frappe.ValidationError, make_sales_order)
def test_payment_entry_against_si_usd_to_usd(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC") pe.reference_no = "1" pe.reference_date = "2016-01-01" pe.target_exchange_rate = 50 pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 5000, si.name], ["_Test Bank USD - _TC", 5000.0, 0, None] ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 0) pe.cancel() outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 100)
def test_payment_entry_against_si_usd_to_inr(self): si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50) pe = get_payment_entry("Sales Invoice", si.name, party_amount=20, bank_account="_Test Bank - _TC", bank_amount=900) pe.reference_no = "1" pe.reference_date = "2016-01-01" self.assertEqual(pe.difference_amount, 100) pe.append( "deductions", { "account": "_Test Exchange Gain/Loss - _TC", "cost_center": "_Test Cost Center - _TC", "amount": 100 }) pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [ ["_Test Receivable USD - _TC", 0, 1000, si.name], ["_Test Bank - _TC", 900, 0, None], ["_Test Exchange Gain/Loss - _TC", 100.0, 0, None], ]) self.validate_gl_entries(pe.name, expected_gle) outstanding_amount = flt( frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount")) self.assertEqual(outstanding_amount, 80)
def test_item_price_with_pricing_rule(self): item = make_item("Water Flask") make_item_price("Water Flask", "_Test Price List", 100) pricing_rule_record = { "doctype": "Pricing Rule", "title": "_Test Water Flask Rule", "apply_on": "Item Code", "items": [{ "item_code": "Water Flask", }], "selling": 1, "currency": "INR", "rate_or_discount": "Rate", "rate": 0, "margin_type": "Percentage", "margin_rate_or_amount": 2, "company": "_Test Company" } rule = frappe.get_doc(pricing_rule_record) rule.insert() si = create_sales_invoice(do_not_save=True, item_code="Water Flask") si.selling_price_list = "_Test Price List" si.save() # If rate in Rule is 0, give preference to Item Price if it exists self.assertEqual(si.items[0].price_list_rate, 100) self.assertEqual(si.items[0].margin_rate_or_amount, 2) self.assertEqual(si.items[0].rate_with_margin, 102) self.assertEqual(si.items[0].rate, 102) si.delete() rule.delete() frappe.get_doc("Item Price", {"item_code": "Water Flask"}).delete() item.delete()
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_deferred_revenue(self): self.clear_old_entries() # created deferred expense accounts, if not found deferred_revenue_account = create_account( account_name="Deferred Revenue", parent_account="Current Liabilities - _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() customer = frappe.new_doc("Customer") customer.customer_name = "_Test Customer DR" customer.type = "Individual" customer.insert() item = create_item( "_Test Internet Subscription", is_stock_item=0, warehouse="All Warehouses - _CD", company="_Test Company DR", ) item.enable_deferred_revenue = 1 item.deferred_revenue_account = deferred_revenue_account item.no_of_months = 3 item.save() si = create_sales_invoice( item=item.name, company="_Test Company DR", customer="_Test Customer DR", debit_to="Debtors - _CD", posting_date="2021-05-01", parent_cost_center="Main - _CD", cost_center="Main - _CD", do_not_save=True, rate=300, price_list_rate=300, ) si.items[0].income_account = "Sales - _CD" si.items[0].enable_deferred_revenue = 1 si.items[0].service_start_date = "2021-05-01" si.items[0].service_end_date = "2021-08-01" si.items[0].deferred_revenue_account = deferred_revenue_account si.items[0].income_account = "Sales - _CD" si.save() si.submit() pda = frappe.get_doc( dict( doctype="Process Deferred Accounting", posting_date=nowdate(), start_date="2021-05-01", end_date="2021-08-01", type="Income", 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": "Revenue", "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 make_sales_invoice(): si = create_sales_invoice(company="_Test Company GST", customer = '_Test GST Customer', currency = 'INR', warehouse = 'Finished Goods - _GST', debit_to = 'Debtors - _GST', income_account = 'Sales - _GST', expense_account = 'Cost of Goods Sold - _GST', cost_center = 'Main - _GST', posting_date = '2019-03-10', do_not_save=1 ) si.append("taxes", { "charge_type": "On Net Total", "account_head": "IGST - _GST", "cost_center": "Main - _GST", "description": "IGST @ 18.0", "rate": 18 }) si.submit() si1 = create_sales_invoice(company="_Test Company GST", customer = '_Test GST SEZ Customer', currency = 'INR', warehouse = 'Finished Goods - _GST', debit_to = 'Debtors - _GST', income_account = 'Sales - _GST', expense_account = 'Cost of Goods Sold - _GST', cost_center = 'Main - _GST', posting_date = '2019-03-10', do_not_save=1 ) si1.append("taxes", { "charge_type": "On Net Total", "account_head": "IGST - _GST", "cost_center": "Main - _GST", "description": "IGST @ 18.0", "rate": 18 }) si1.submit() si2 = create_sales_invoice(company="_Test Company GST", customer = '_Test Unregistered Customer', currency = 'INR', warehouse = 'Finished Goods - _GST', debit_to = 'Debtors - _GST', income_account = 'Sales - _GST', expense_account = 'Cost of Goods Sold - _GST', cost_center = 'Main - _GST', posting_date = '2019-03-10', do_not_save=1 ) si2.append("taxes", { "charge_type": "On Net Total", "account_head": "IGST - _GST", "cost_center": "Main - _GST", "description": "IGST @ 18.0", "rate": 18 }) si2.submit() si3 = create_sales_invoice(company="_Test Company GST", customer = '_Test GST Customer', currency = 'INR', item = 'Milk', warehouse = 'Finished Goods - _GST', debit_to = 'Debtors - _GST', income_account = 'Sales - _GST', expense_account = 'Cost of Goods Sold - _GST', cost_center = 'Main - _GST', posting_date = '2019-03-10', do_not_save=1 ) si3.submit()
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_accounting_period(self): ap1 = create_accounting_period(period_name = "Test Accounting Period 2") ap1.save() doc = create_sales_invoice(do_not_submit=1, cost_center = "_Test Company - _TC", warehouse = "Stores - _TC") self.assertRaises(ClosedAccountingPeriod, doc.submit)