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')
