def get_customer_outstanding_amount(self): 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 get_customer_outstanding_amount(self): from erpnext.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_dn_billing_status_case2(self): # SO -> SI and SO -> DN1, DN2 from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note, make_sales_invoice so = make_sales_order() si = make_sales_invoice(so.name) si.get("items")[0].qty = 5 si.insert() si.submit() frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) dn1 = make_delivery_note(so.name) dn1.posting_time = "10:00" dn1.get("items")[0].qty = 2 dn1.submit() self.assertEqual(dn1.get("items")[0].billed_amt, 200) self.assertEqual(dn1.per_billed, 100) self.assertEqual(dn1.status, "Completed") dn2 = make_delivery_note(so.name) dn2.posting_time = "08:00" dn2.get("items")[0].qty = 4 dn2.submit() dn1.load_from_db() self.assertEqual(dn1.get("items")[0].billed_amt, 100) self.assertEqual(dn1.per_billed, 50) self.assertEqual(dn1.status, "To Bill") self.assertEqual(dn2.get("items")[0].billed_amt, 400) self.assertEqual(dn2.per_billed, 100) self.assertEqual(dn2.status, "Completed")
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_delivery_note_return_against_sales_order(self, item_code, delivered_qty, returned_qty): from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice actual_qty_0 = get_qty_after_transaction() so = make_sales_order(qty=50) dn = create_dn_against_so(so.name, delivered_qty) actual_qty_1 = get_qty_after_transaction() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si = make_sales_invoice(so.name) si.insert() si.submit() # insert and submit stock entry for sales return se = make_stock_entry( item_code="_Test Item", target="_Test Warehouse - _TC", qty=returned_qty, purpose="Sales Return", delivery_note_no=dn.name, ) actual_qty_2 = get_qty_after_transaction() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def test_pricing_rule_for_stock_qty(self): frappe.db.sql("delete from `tabPricing Rule`") test_record = { "doctype": "Pricing Rule", "title": "_Test Pricing Rule", "apply_on": "Item Code", "item_code": "_Test Item", "selling": 1, "price_or_discount": "Discount Percentage", "price": 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.assertEquals(so.items[0].discount_percentage, 17.5) self.assertEquals(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.assertEquals(so.items[0].discount_percentage, 0) self.assertEquals(so.items[0].rate, 100)
def test_freezed_customer(self): frappe.db.set_value("Customer", "_Test Customer", "is_frozen", 1) from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order so = make_sales_order(do_not_save= True) self.assertRaises(CustomerFrozen, so.save) frappe.db.set_value("Customer", "_Test Customer", "is_frozen", 0) so.save()
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_disabled_customer(self): make_test_records("Item") frappe.db.set_value("Customer", "_Test Customer", "disabled", 1) from erpnext.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_freezed_customer(self): make_test_records("Item") frappe.db.set_value("Customer", "_Test Customer", "is_frozen", 1) from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order so = make_sales_order(do_not_save=True) self.assertRaises(PartyFrozen, so.save) frappe.db.set_value("Customer", "_Test Customer", "is_frozen", 0) so.save()
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 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_production_plan_pending_qty_with_sales_order(self): """ Test Prod Plan impact via: SO -> Prod Plan -> WO -> SE -> SE (cancel) """ from erpnext.manufacturing.doctype.work_order.test_work_order import make_wo_order_test_record from erpnext.manufacturing.doctype.work_order.work_order import ( make_stock_entry as make_se_from_wo, ) make_stock_entry(item_code="Raw Material Item 1", target="Work In Progress - _TC", qty=2, basic_rate=100) make_stock_entry(item_code="Raw Material Item 2", target="Work In Progress - _TC", qty=2, basic_rate=100) item = "Test Production Item 1" so = make_sales_order(item_code=item, qty=1) pln = create_production_plan(company=so.company, get_items_from="Sales Order", sales_order=so, skip_getting_mr_items=True) self.assertEqual(pln.po_items[0].pending_qty, 1) wo = make_wo_order_test_record( item_code=item, qty=1, company=so.company, wip_warehouse="Work In Progress - _TC", fg_warehouse="Finished Goods - _TC", skip_transfer=1, use_multi_level_bom=1, do_not_submit=True, ) wo.production_plan = pln.name wo.production_plan_item = pln.po_items[0].name wo.submit() se = frappe.get_doc(make_se_from_wo(wo.name, "Manufacture", 1)) se.submit() pln.reload() self.assertEqual(pln.po_items[0].pending_qty, 0) se.cancel() pln.reload() self.assertEqual(pln.po_items[0].pending_qty, 1)
def test_dn_billing_status_case3(self): # SO -> DN1 -> SI and SO -> SI and SO -> DN2 from erpnext.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.set_posting_time = 1 dn1.posting_time = "10:00" 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.posting_time = "08:00" 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_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) si = make_sales_invoice(dn.name) si.submit() 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_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) si = make_sales_invoice(dn.name) si.submit() 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_updating_bundle_item(self): "Test impact on packed items if bundle item row is updated." so = make_sales_order(item_code=self.bundle, qty=1, do_not_submit=True) so.items[0].qty = 2 # change qty so.save() self.assertEqual(so.packed_items[0].qty, 4) self.assertEqual(so.packed_items[1].qty, 4) # change item code to non bundle item so.items[0].item_code = self.normal_item so.save() self.assertEqual(len(so.packed_items), 0)
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_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 create_sales_order(self, transaction_date): item = create_item(item_code="_Test Excavator", is_stock_item=0) so = make_sales_order( transaction_date=transaction_date, item=item.item_code, qty=10, rate=100000, do_not_save=True, ) so.po_no = "" so.taxes_and_charges = "" so.taxes = "" so.items[0].delivery_date = add_days(transaction_date, 15) so.save() so.submit() return item, so
def test_dn_billing_status_case4(self): # SO -> SI -> DN from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note so = make_sales_order() si = make_sales_invoice(so.name) si.submit() dn = make_delivery_note(si.name) dn.submit() self.assertEqual(dn.get("items")[0].billed_amt, 1000) 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.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_dn_billing_status_case4(self): # SO -> SI -> DN from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note so = make_sales_order() si = make_sales_invoice(so.name) si.submit() dn = make_delivery_note(si.name) dn.submit() self.assertEqual(dn.get("items")[0].billed_amt, 1000) self.assertEqual(dn.per_billed, 100) self.assertEqual(dn.status, "Completed")
def test_2_sales_order_with_coupon_code(self): so = make_sales_order(customer="_Test Customer", selling_price_list="_Test Price List", item_code="_Test Tesla Car", rate=5000, qty=1, do_not_submit=True) so = frappe.get_doc('Sales Order', so.name) # check item price before coupon code is applied 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()
def test_make_sales_invoice_from_dn_for_returned_qty(self): from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note from erpnext.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.submit() si = make_sales_invoice(dn.name) self.assertEquals(si.items[0].qty, 1)
def test_make_sales_invoice_from_dn_for_returned_qty(self): from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note from erpnext.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.submit() si = make_sales_invoice(dn.name) self.assertEquals(si.items[0].qty, 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_picklist_with_multi_uom(self): warehouse = "_Test Warehouse - _TC" item = make_item(properties={ "uoms": [dict(uom="Box", conversion_factor=24)] }).name make_stock_entry(item=item, to_warehouse=warehouse, qty=1000) so = make_sales_order(item_code=item, qty=10, rate=42, uom="Box") pl = create_pick_list(so.name) # pick half the qty for loc in pl.locations: loc.picked_qty = loc.stock_qty / 2 pl.save() pl.submit() so.reload() self.assertEqual(so.per_picked, 50)
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_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_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_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_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_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_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_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(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 test_dn_billing_status_case2(self): # SO -> SI and SO -> DN1, DN2 from erpnext.selling.doctype.sales_order.sales_order import ( make_delivery_note, make_sales_invoice, ) so = make_sales_order() si = make_sales_invoice(so.name) si.get("items")[0].qty = 5 si.insert() si.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(so.po_no, si.po_no) frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) 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(so.po_no, dn1.po_no) dn2 = make_delivery_note(so.name) dn2.get("items")[0].qty = 3 dn2.submit() # Testing if Customer's Purchase Order No was rightly copied self.assertEqual(so.po_no, dn2.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, 300) self.assertEqual(dn2.per_billed, 100) self.assertEqual(dn2.status, "Completed")
def test_change_applicable_for_in_promotional_scheme(self): ps = make_promotional_scheme() price_rules = frappe.get_all("Pricing Rule", filters={"promotional_scheme": ps.name}) self.assertTrue(len(price_rules), 1) so = make_sales_order(qty=5, currency="USD", do_not_save=True) so.set_missing_values() so.save() self.assertEqual(price_rules[0].name, so.pricing_rules[0].pricing_rule) ps.applicable_for = "Customer" ps.append("customer", {"customer": "_Test Customer"}) self.assertRaises(TransactionExists, ps.save) frappe.delete_doc("Sales Order", so.name) frappe.delete_doc("Promotional Scheme", ps.name) price_rules = frappe.get_all("Pricing Rule", filters={"promotional_scheme": ps.name}) self.assertEqual(price_rules, [])
def test_newly_mapped_doc_packed_items(self): "Test impact on packed items in newly mapped DN from SO." so_items = [] for qty in [2, 4]: so_items.append({ "item_code": self.bundle, "qty": qty, "rate": 400, "warehouse": "_Test Warehouse - _TC" }) # create SO with recurring bundle item so = make_sales_order(item_list=so_items) dn = make_delivery_note(so.name) dn.items[1].qty = 3 # change second row qty for inserting doc dn.save() self.assertEqual(len(dn.packed_items), 4) self.assertEqual(dn.packed_items[2].qty, 6) self.assertEqual(dn.packed_items[3].qty, 6)
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_projected_qty_for_production_and_sales_order(self): before_production_order = get_bin(self.item, self.warehouse) before_production_order.update_reserved_qty_for_production() self.pro_order = make_prod_order_test_record(item="_Test FG Item", qty=2, source_warehouse=self.warehouse) after_production_order = get_bin(self.item, self.warehouse) sales_order = make_sales_order(item = self.item, qty = 2) after_sales_order = get_bin(self.item, self.warehouse) self.assertEqual(cint(before_production_order.reserved_qty_for_production) + 2, cint(after_sales_order.reserved_qty_for_production)) self.assertEqual(cint(before_production_order.projected_qty), cint(after_sales_order.projected_qty) + 2) total_projected_qty = get_total_projected_qty(self.item) item_doc = frappe.get_doc('Item', self.item) self.assertEqual(total_projected_qty, item_doc.total_projected_qty)
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_projected_qty_for_production_and_sales_order(self): before_production_order = get_bin(self.item, self.warehouse) before_production_order.update_reserved_qty_for_production() self.pro_order = make_prod_order_test_record(item="_Test FG Item", qty=2, source_warehouse=self.warehouse) after_production_order = get_bin(self.item, self.warehouse) sales_order = make_sales_order(item=self.item, qty=2) after_sales_order = get_bin(self.item, self.warehouse) self.assertEqual( cint(before_production_order.reserved_qty_for_production) + 2, cint(after_sales_order.reserved_qty_for_production), ) self.assertEqual(cint(before_production_order.projected_qty), cint(after_sales_order.projected_qty) + 2) total_projected_qty = get_total_projected_qty(self.item) item_doc = frappe.get_doc("Item", self.item) self.assertEqual(total_projected_qty, item_doc.total_projected_qty)
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_recurring_bundle_item(self): "Test impact on packed items if same bundle item is added and removed." so_items = [] for qty in [2, 4, 6, 8]: so_items.append({ "item_code": self.bundle, "qty": qty, "rate": 400, "warehouse": "_Test Warehouse - _TC" }) # create SO with recurring bundle item so = make_sales_order(item_list=so_items, do_not_submit=True) # check alternate rows for qty self.assertEqual(len(so.packed_items), 8) self.assertEqual(so.packed_items[1].item_code, self.bundle_items[1]) self.assertEqual(so.packed_items[1].qty, 4) self.assertEqual(so.packed_items[3].qty, 8) self.assertEqual(so.packed_items[5].qty, 12) self.assertEqual(so.packed_items[7].qty, 16) # delete intermediate row (2nd) del so.items[1] so.save() # check alternate rows for qty self.assertEqual(len(so.packed_items), 6) self.assertEqual(so.packed_items[1].qty, 4) self.assertEqual(so.packed_items[3].qty, 12) self.assertEqual(so.packed_items[5].qty, 16) # delete last row del so.items[2] so.save() # check alternate rows for qty self.assertEqual(len(so.packed_items), 4) self.assertEqual(so.packed_items[1].qty, 4) self.assertEqual(so.packed_items[3].qty, 12)
def test_reposting_packed_items(self): warehouse = "Stores - TCP1" company = "_Test Company with perpetual inventory" today = nowdate() yesterday = add_to_date(today, days=-1, as_string=True) for item in self.bundle_items: make_stock_entry(item_code=item, to_warehouse=warehouse, qty=10, rate=100, posting_date=today) so = make_sales_order(item_code=self.bundle, qty=1, company=company, warehouse=warehouse) dn = make_delivery_note(so.name) dn.save() dn.submit() gles = get_gl_entries(dn.doctype, dn.name) credit_before_repost = sum(gle.credit for gle in gles) # backdated stock entry for item in self.bundle_items: make_stock_entry(item_code=item, to_warehouse=warehouse, qty=10, rate=200, posting_date=yesterday) # assert correct reposting gles = get_gl_entries(dn.doctype, dn.name) credit_after_reposting = sum(gle.credit for gle in gles) self.assertNotEqual(credit_before_repost, credit_after_reposting) self.assertAlmostEqual(credit_after_reposting, 2 * credit_before_repost)
def test_returning_partial_bundles(self): from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_return item_list = [ { "item_code": self.bundle, "warehouse": self.warehouse, "qty": 1, "rate": 100, }, { "item_code": self.bundle2, "warehouse": self.warehouse, "qty": 1, "rate": 100, }, ] so = make_sales_order(item_list=item_list, warehouse=self.warehouse) dn = make_delivery_note(so.name) dn.save() dn.submit() # create return dn_ret = make_sales_return(dn.name) # remove bundle 2 dn_ret.items.pop() dn_ret.save() dn_ret.submit() dn_ret.reload() self.assertTrue( all(d.parent_item == self.bundle for d in dn_ret.packed_items)) expected_returns = [ d for d in dn.packed_items if d.parent_item == self.bundle ] self.assertReturns(expected_returns, dn_ret.packed_items)
def test_returning_partial_bundle_qty(self): from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_return so = make_sales_order(item_code=self.bundle, warehouse=self.warehouse, qty=2) dn = make_delivery_note(so.name) dn.save() dn.submit() # create return dn_ret = make_sales_return(dn.name) # halve the qty dn_ret.items[0].qty = -1 dn_ret.save() dn_ret.submit() expected_returns = dn.packed_items for d in expected_returns: d.qty /= 2 self.assertReturns(expected_returns, dn_ret.packed_items)
def test_dn_billing_status_case4(self): # SO -> SI -> DN from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice 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_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() self.assertFalse(self.get_gle(pe.name)) so_advance_paid = frappe.db.get_value("Sales Order", so.name, "advance_paid") self.assertEqual(so_advance_paid, 0)
def test_dn_billing_status_case2(self): # SO -> SI and SO -> DN1, DN2 from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note, make_sales_invoice so = make_sales_order() si = make_sales_invoice(so.name) si.get("items")[0].qty = 5 si.insert() si.submit() frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) dn1 = make_delivery_note(so.name) dn1.set_posting_time = 1 dn1.posting_time = "10:00" dn1.get("items")[0].qty = 2 dn1.submit() self.assertEqual(dn1.get("items")[0].billed_amt, 200) self.assertEqual(dn1.per_billed, 100) self.assertEqual(dn1.status, "Completed") dn2 = make_delivery_note(so.name) dn2.set_posting_time = 1 dn2.posting_time = "08:00" dn2.get("items")[0].qty = 4 dn2.submit() dn1.load_from_db() self.assertEqual(dn1.get("items")[0].billed_amt, 100) self.assertEqual(dn1.per_billed, 50) self.assertEqual(dn1.status, "To Bill") self.assertEqual(dn2.get("items")[0].billed_amt, 400) self.assertEqual(dn2.per_billed, 100) self.assertEqual(dn2.status, "Completed")
def test_make_journal_entry(self): self.clear_table_entries() frappe.db.set_default("currency", "INR") base_customer_jv = self.create_against_jv(jv_test_records[2], { "party": "_Test Customer 3"}) base_supplier_jv = self.create_against_jv(jv_test_records[1], { "party": "_Test Supplier 1"}) # Create SO with partial outstanding so1 = make_sales_order(customer="_Test Customer 3", qty=10, rate=100) self.create_against_jv(jv_test_records[0], { "party": "_Test Customer 3", "reference_type": "Sales Order", "reference_name": so1.name, "is_advance": "Yes" }) #Create SO with no outstanding so2 = make_sales_order(customer="_Test Customer 3") self.create_against_jv(jv_test_records[0], { "party": "_Test Customer 3", "reference_type": "Sales Order", "reference_name": so2.name, "credit_in_account_currency": 1000, "is_advance": "Yes" }) # Purchase order po = create_purchase_order(supplier="_Test Supplier 1") #Create SI with partial outstanding si1 = self.create_voucher(si_test_records[0], { "customer": "_Test Customer 3", "debit_to": "_Test Receivable - _TC" }) self.create_against_jv(jv_test_records[0], { "party": "_Test Customer 3", "reference_type": si1.doctype, "reference_name": si1.name }) #Create SI with no outstanding si2 = self.create_voucher(si_test_records[0], { "customer": "_Test Customer 3", "debit_to": "_Test Receivable - _TC" }) self.create_against_jv(jv_test_records[0], { "party": "_Test Customer 3", "reference_type": si2.doctype, "reference_name": si2.name, "credit_in_account_currency": 561.80 }) pi = self.create_voucher(pi_test_records[0], { "supplier": "_Test Supplier 1", "credit_to": "_Test Payable - _TC" }) #Create a dict containing properties and expected values expected_outstanding = { "Journal Entry" : [base_customer_jv.name, 400.00], "Sales Invoice" : [si1.name, 161.80], "Purchase Invoice" : [pi.name, 1512.30], "Sales Order" : [so1.name, 600.00], "Purchase Order" : [po.name, 5000.00] } args = { "company": "_Test Company", "party_type": "Customer", "received_or_paid": "Received", "party": "_Test Customer 3", "party_account": "_Test Receivable - _TC", "payment_mode": "Cheque", "payment_account": "_Test Bank - _TC", "reference_no": "123456", "reference_date": "2013-02-14" } self.make_voucher_for_party(args, expected_outstanding) args.update({ "party_type": "Supplier", "received_or_paid": "Paid", "party": "_Test Supplier 1", "party_account": "_Test Payable - _TC" }) expected_outstanding["Journal Entry"] = [base_supplier_jv.name, 400.00] self.make_voucher_for_party(args, expected_outstanding)
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')
def test_jv_against_sales_order(self): from erpnext.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)