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)
