def get_customer_outstanding_amount(self): from erpbee.selling.doctype.sales_order.test_sales_order import make_sales_order outstanding_amt = get_customer_outstanding('_Test Customer', '_Test Company') # If outstanding is negative make a transaction to get positive outstanding amount if outstanding_amt > 0.0: return outstanding_amt item_qty = int((abs(outstanding_amt) + 200)/100) make_sales_order(qty=item_qty) return get_customer_outstanding('_Test Customer', '_Test Company')
def test_pricing_rule_for_stock_qty(self): test_record = { "doctype": "Pricing Rule", "title": "_Test Pricing Rule", "apply_on": "Item Code", "currency": "USD", "items": [{ "item_code": "_Test Item", }], "selling": 1, "rate_or_discount": "Discount Percentage", "rate": 0, "min_qty": 5, "max_qty": 7, "discount_percentage": 17.5, "company": "_Test Company" } frappe.get_doc(test_record.copy()).insert() if not frappe.db.get_value('UOM Conversion Detail', { 'parent': '_Test Item', 'uom': 'box' }): item = frappe.get_doc('Item', '_Test Item') item.append('uoms', {'uom': 'Box', 'conversion_factor': 5}) item.save(ignore_permissions=True) # With pricing rule so = make_sales_order(item_code="_Test Item", qty=1, uom="Box", do_not_submit=True) so.items[0].price_list_rate = 100 so.submit() so = frappe.get_doc('Sales Order', so.name) self.assertEqual(so.items[0].discount_percentage, 17.5) self.assertEqual(so.items[0].rate, 82.5) # Without pricing rule so = make_sales_order(item_code="_Test Item", qty=2, uom="Box", do_not_submit=True) so.items[0].price_list_rate = 100 so.submit() so = frappe.get_doc('Sales Order', so.name) self.assertEqual(so.items[0].discount_percentage, 0) self.assertEqual(so.items[0].rate, 100)
def test_pricing_rule_for_product_discount_on_different_item(self): frappe.delete_doc_if_exists('Pricing Rule', '_Test Pricing Rule') test_record = { "doctype": "Pricing Rule", "title": "_Test Pricing Rule", "apply_on": "Item Code", "currency": "USD", "items": [{ "item_code": "_Test Item", }], "selling": 1, "rate_or_discount": "Discount Percentage", "rate": 0, "min_qty": 0, "max_qty": 7, "discount_percentage": 17.5, "price_or_product_discount": "Product", "same_item": 0, "free_item": "_Test Item 2", "free_qty": 1, "company": "_Test Company" } frappe.get_doc(test_record.copy()).insert() # With pricing rule so = make_sales_order(item_code="_Test Item", qty=1) so.load_from_db() self.assertEqual(so.items[1].is_free_item, 1) self.assertEqual(so.items[1].item_code, "_Test Item 2")
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, 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="_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_result_for_partial_material_request(self): so = make_sales_order() mr = make_material_request(so.name) mr.items[0].qty = 4 mr.schedule_date = add_months(nowdate(), 1) mr.submit() report = execute() l = len(report[1]) self.assertEqual((so.items[0].qty - mr.items[0].qty), report[1][l - 1]['pending_qty'])
def test_production_plan_sales_orders(self): item = 'Test Production Item 1' so = make_sales_order(item_code=item, qty=5) sales_order = so.name sales_order_item = so.items[0].name pln = frappe.new_doc('Production Plan') pln.company = so.company pln.get_items_from = 'Sales Order' pln.append( 'sales_orders', { 'sales_order': so.name, 'sales_order_date': so.transaction_date, 'customer': so.customer, 'grand_total': so.grand_total }) pln.get_so_items() pln.submit() pln.make_work_order() work_order = frappe.db.get_value( 'Work Order', { 'sales_order': sales_order, 'production_plan': pln.name, 'sales_order_item': sales_order_item }, 'name') wo_doc = frappe.get_doc('Work Order', work_order) wo_doc.update({ 'wip_warehouse': '_Test Warehouse 1 - _TC', 'fg_warehouse': '_Test Warehouse - _TC' }) wo_doc.submit() so_wo_qty = frappe.db.get_value('Sales Order Item', sales_order_item, 'work_order_qty') self.assertTrue(so_wo_qty, 5) pln = frappe.new_doc('Production Plan') pln.update({ 'from_date': so.transaction_date, 'to_date': so.transaction_date, 'customer': so.customer, 'item_code': item, 'sales_order_status': so.status }) sales_orders = get_sales_orders(pln) or {} sales_orders = [ d.get('name') for d in sales_orders if d.get('name') == sales_order ] self.assertEqual(sales_orders, [])
def test_disabled_customer(self): make_test_records("Item") frappe.db.set_value("Customer", "_Test Customer", "disabled", 1) from erpbee.selling.doctype.sales_order.test_sales_order import make_sales_order so = make_sales_order(do_not_save=True) self.assertRaises(PartyDisabled, so.save) frappe.db.set_value("Customer", "_Test Customer", "disabled", 0) so.save()
def test_customer_credit_limit(self): from erpbee.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from erpbee.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice from erpbee.selling.doctype.sales_order.test_sales_order import make_sales_order from erpbee.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 not credit_limit: set_credit_limit('_Test Customer', '_Test Company', outstanding_amt - 50) # 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: set_credit_limit('_Test Customer', '_Test Company', 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_dn_billing_status_case3(self): # SO -> DN1 -> SI and SO -> SI and SO -> DN2 from erpbee.selling.doctype.sales_order.sales_order \ import make_delivery_note, make_sales_invoice as make_sales_invoice_from_so frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) so = make_sales_order() dn1 = make_delivery_note(so.name) dn1.get("items")[0].qty = 2 dn1.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn1.po_no, so.po_no) si1 = make_sales_invoice(dn1.name) si1.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn1.po_no, si1.po_no) dn1.load_from_db() self.assertEqual(dn1.per_billed, 100) si2 = make_sales_invoice_from_so(so.name) si2.get("items")[0].qty = 4 si2.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(si2.po_no, so.po_no) dn2 = make_delivery_note(so.name) dn2.get("items")[0].qty = 5 dn2.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn2.po_no, so.po_no) dn1.load_from_db() self.assertEqual(dn1.get("items")[0].billed_amt, 200) self.assertEqual(dn1.per_billed, 100) self.assertEqual(dn1.status, "Completed") self.assertEqual(dn2.get("items")[0].billed_amt, 400) self.assertEqual(dn2.per_billed, 80) self.assertEqual(dn2.status, "To Bill")
def test_sales_order_with_coupon_code(self): frappe.db.set_value("Coupon Code", "SAVE30", "used", 0) so = make_sales_order(company='_Test Company', warehouse='Stores - _TC', customer="_Test Customer", selling_price_list="_Test Price List", item_code="_Test Tesla Car", rate=5000, qty=1, do_not_submit=True) self.assertEqual(so.items[0].rate, 5000) so.coupon_code='SAVE30' so.sales_partner='_Test Coupon Partner' so.save() # check item price after coupon code is applied self.assertEqual(so.items[0].rate, 3500) so.submit() self.assertEqual(frappe.db.get_value("Coupon Code", "SAVE30", "used"), 1)
def test_over_production_for_sales_order(self): so = make_sales_order(item_code="_Test FG Item", qty=2) allow_overproduction("overproduction_percentage_for_sales_order", 0) wo_order = make_wo_order_test_record(planned_start_date=now(), sales_order=so.name, qty=3, do_not_save=True) self.assertRaises(OverProductionError, wo_order.save) allow_overproduction("overproduction_percentage_for_sales_order", 50) wo_order = make_wo_order_test_record(planned_start_date=now(), sales_order=so.name, qty=3) wo_order.submit() self.assertEqual(wo_order.docstatus, 1) allow_overproduction("overproduction_percentage_for_sales_order", 0)
def test_make_sales_invoice_from_dn_for_returned_qty(self): from erpbee.selling.doctype.sales_order.sales_order import make_delivery_note from erpbee.stock.doctype.delivery_note.delivery_note import make_sales_invoice so = make_sales_order(qty=2) so.submit() dn = make_delivery_note(so.name) dn.submit() dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-1, do_not_submit=True) dn1.items[0].against_sales_order = so.name dn1.items[0].so_detail = so.items[0].name dn1.items[0].dn_detail = dn.items[0].name dn1.submit() si = make_sales_invoice(dn.name) self.assertEquals(si.items[0].qty, 1)
def test_dn_billing_status_case1(self): # SO -> DN -> SI so = make_sales_order() dn = create_dn_against_so(so.name, delivered_qty=2) self.assertEqual(dn.status, "To Bill") self.assertEqual(dn.per_billed, 0) # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn.po_no, so.po_no) si = make_sales_invoice(dn.name) si.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn.po_no, si.po_no) dn.load_from_db() self.assertEqual(dn.get("items")[0].billed_amt, 200) self.assertEqual(dn.per_billed, 100) self.assertEqual(dn.status, "Completed")
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.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="*****@*****.**") self.assertEqual(pr.reference_doctype, "Sales Invoice") self.assertEqual(pr.reference_name, si_usd.name) self.assertEqual(pr.currency, "USD")
def test_dn_billing_status_case4(self): # SO -> SI -> DN from erpbee.selling.doctype.sales_order.sales_order import make_sales_invoice from erpbee.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note so = make_sales_order() si = make_sales_invoice(so.name) si.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(so.po_no, si.po_no) dn = make_delivery_note(si.name) dn.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(dn.po_no, si.po_no) self.assertEqual(dn.get("items")[0].billed_amt, 1000) self.assertEqual(dn.per_billed, 100) self.assertEqual(dn.status, "Completed")
def test_multiple_payment_entries_against_sales_order(self): # Make Sales Order, grand_total = 1000 so = make_sales_order() # Payment Request amount = 200 pr1 = make_payment_request(dt="Sales Order", dn=so.name, recipient_id="*****@*****.**", return_doc=1) pr1.grand_total = 200 pr1.submit() # Make a 2nd Payment Request pr2 = make_payment_request(dt="Sales Order", dn=so.name, recipient_id="*****@*****.**", return_doc=1) self.assertEqual(pr2.grand_total, 800) # Try to make Payment Request more than SO amount, should give validation pr2.grand_total = 900 self.assertRaises(frappe.ValidationError, pr2.save)
def test_payment_entry_against_order(self): so = make_sales_order() pe = get_payment_entry("Sales Order", so.name, bank_account="_Test Cash - _TC") pe.paid_from = "Debtors - _TC" pe.insert() pe.submit() expected_gle = dict((d[0], d) for d in [["Debtors - _TC", 0, 1000, so.name], ["_Test Cash - _TC", 1000.0, 0, None]]) self.validate_gl_entries(pe.name, expected_gle) so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid") self.assertEqual(so_advance_paid, 1000) pe.cancel() so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid") self.assertEqual(so_advance_paid, 0)
def test_jv_against_sales_order(self): from erpbee.selling.doctype.sales_order.test_sales_order import make_sales_order sales_order = make_sales_order(do_not_save=True) base_jv = frappe.copy_doc(test_records[0]) self.jv_against_voucher_testcase(base_jv, sales_order)
def test_result_for_so_item(self): so = make_sales_order() report = execute() l = len(report[1]) self.assertEqual(so.items[0].qty, report[1][l - 1]['pending_qty'])
def create_sales_orders(): frappe.set_user("Administrator") make_sales_order(company="_Test Company 2", qty=10, customer="_Test Customer 1", transaction_date='2018-02-10', warehouse='Finished Goods - _TC2', currency='EUR') make_sales_order(company="_Test Company 2", qty=10, customer="_Test Customer 1", transaction_date='2018-02-15', warehouse='Finished Goods - _TC2', currency='EUR') make_sales_order(company="_Test Company 2", qty=10, customer="_Test Customer 2", transaction_date='2017-10-10', warehouse='Finished Goods - _TC2', currency='EUR') make_sales_order(company="_Test Company 2", qty=15, customer="_Test Customer 2", transaction_date='2017-09-23', warehouse='Finished Goods - _TC2', currency='EUR') make_sales_order(company="_Test Company 2", qty=20, customer="_Test Customer 3", transaction_date='2017-06-15', warehouse='Finished Goods - _TC2', currency='EUR') make_sales_order(company="_Test Company 2", qty=10, customer="_Test Customer 3", transaction_date='2017-07-10', warehouse='Finished Goods - _TC2', currency='EUR')