def test_update_child_qty_rate(self):
so = make_sales_order(item_code="_Test Item", qty=4)
create_dn_against_so(so.name, 4)
make_sales_invoice(so.name)
existing_reserved_qty = get_reserved_qty()
trans_item = json.dumps([{
'item_code': '_Test Item',
'rate': 200,
'qty': 7,
'docname': so.items[0].name
}])
update_child_qty_rate('Sales Order', trans_item, so.name)
so.reload()
self.assertEqual(so.get("items")[0].rate, 200)
self.assertEqual(so.get("items")[0].qty, 7)
self.assertEqual(so.get("items")[0].amount, 1400)
self.assertEqual(so.status, 'To Deliver and Bill')
self.assertEqual(get_reserved_qty(), existing_reserved_qty + 3)
trans_item = json.dumps([{
'item_code': '_Test Item',
'rate': 200,
'qty': 2,
'docname': so.items[0].name
}])
self.assertRaises(dataent.ValidationError, update_child_qty_rate,
'Sales Order', trans_item, so.name)
def test_make_sales_invoice_with_terms(self):
so = make_sales_order(do_not_submit=True)
self.assertRaises(dataent.ValidationError, make_sales_invoice, so.name)
so.update({"payment_terms_template": "_Test Payment Term Template"})
so.save()
so.submit()
si = make_sales_invoice(so.name)
self.assertEqual(len(si.get("items")), len(so.get("items")))
self.assertEqual(len(si.get("items")), 1)
si.insert()
self.assertEqual(si.payment_schedule[0].payment_amount, 500.0)
self.assertEqual(si.payment_schedule[0].due_date, so.transaction_date)
self.assertEqual(si.payment_schedule[1].payment_amount, 500.0)
self.assertEqual(si.payment_schedule[1].due_date,
add_days(so.transaction_date, 30))
si.submit()
si1 = make_sales_invoice(so.name)
self.assertEqual(len(si1.get("items")), 0)
def test_update_qty(self):
so = make_sales_order()
create_dn_against_so(so.name, 6)
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 6)
# Check delivered_qty after make_sales_invoice without update_stock checked
si1 = make_sales_invoice(so.name)
si1.get("items")[0].qty = 6
si1.insert()
si1.submit()
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 6)
# Check delivered_qty after make_sales_invoice with update_stock checked
si2 = make_sales_invoice(so.name)
si2.set("update_stock", 1)
si2.get("items")[0].qty = 3
si2.insert()
si2.submit()
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 9)
def test_make_sales_invoice(self):
so = make_sales_order(do_not_submit=True)
self.assertRaises(dataent.ValidationError, make_sales_invoice, so.name)
so.submit()
si = make_sales_invoice(so.name)
self.assertEqual(len(si.get("items")), len(so.get("items")))
self.assertEqual(len(si.get("items")), 1)
si.insert()
si.submit()
si1 = make_sales_invoice(so.name)
self.assertEqual(len(si1.get("items")), 0)
def test_reserved_qty_for_over_delivery_via_sales_invoice(self):
make_stock_entry(target="_Test Warehouse - _TC", qty=10, rate=100)
# set over-delivery tolerance
dataent.db.set_value('Item', "_Test Item", 'tolerance', 50)
existing_reserved_qty = get_reserved_qty()
so = make_sales_order()
self.assertEqual(get_reserved_qty(), existing_reserved_qty + 10)
si = make_sales_invoice(so.name)
si.update_stock = 1
si.get("items")[0].qty = 12
si.insert()
si.submit()
self.assertEqual(get_reserved_qty(), existing_reserved_qty)
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 12)
self.assertEqual(so.per_delivered, 100)
si.cancel()
self.assertEqual(get_reserved_qty(), existing_reserved_qty + 10)
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 0)
self.assertEqual(so.per_delivered, 0)
def make_invoice(self):
ref_doc = dataent.get_doc(self.reference_doctype, self.reference_name)
if (hasattr(ref_doc, "order_type")
and getattr(ref_doc, "order_type") == "Shopping Cart"):
from epaas.selling.doctype.sales_order.sales_order import make_sales_invoice
si = make_sales_invoice(self.reference_name,
ignore_permissions=True)
si = si.insert(ignore_permissions=True)
si.submit()
def test_terms_copied(self):
so = make_sales_order(do_not_copy=1, do_not_save=1)
so.payment_terms_template = '_Test Payment Term Template'
so.insert()
so.submit()
self.assertTrue(so.get('payment_schedule'))
si = make_sales_invoice(so.name)
si.insert()
self.assertTrue(si.get('payment_schedule'))
def work():
dataent.set_user(dataent.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
si = dataent.get_doc(make_sales_invoice(so))
si.posting_date = dataent.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
dataent.db.commit()
except dataent.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
pi = dataent.get_doc(make_purchase_invoice(pr))
pi.posting_date = dataent.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
dataent.db.commit()
except dataent.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.4:
#make payment request against sales invoice
sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = dataent.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = dataent.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = dataent.flags.current_date
payment_entry.submit()
make_pos_invoice()
def create_sales_invoice(shopify_order, shopify_settings, so):
if not dataent.db.get_value("Sales Invoice", {"shopify_order_id": shopify_order.get("id")}, "name")\
and so.docstatus==1 and not so.per_billed and cint(shopify_settings.sync_sales_invoice):
si = make_sales_invoice(so.name, ignore_permissions=True)
si.shopify_order_id = shopify_order.get("id")
si.naming_series = shopify_settings.sales_invoice_series or "SI-Shopify-"
si.flags.ignore_mandatory = True
set_cost_center(si.items, shopify_settings.cost_center)
si.submit()
make_payament_entry_against_sales_invoice(si, shopify_settings)
dataent.db.commit()
def test_so_billed_amount_against_return_entry(self):
from epaas.accounts.doctype.sales_invoice.sales_invoice import make_sales_return
so = make_sales_order(do_not_submit=True)
so.submit()
si = make_sales_invoice(so.name)
si.insert()
si.submit()
si1 = make_sales_return(si.name)
si1.update_billed_amount_in_sales_order = 1
si1.submit()
so.load_from_db()
self.assertEquals(so.per_billed, 0)
def make_pos_invoice():
make_sales_order()
for data in dataent.get_all('Sales Order', fields=["name"],
filters = [["per_billed", "<", "100"]]):
si = dataent.get_doc(make_sales_invoice(data.name))
si.is_pos =1
si.posting_date = dataent.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr'))
si.set_missing_values()
make_payment_entries_for_pos_invoice(si)
si.insert()
si.submit()
def test_return_against_sales_order(self):
so = make_sales_order()
dn = create_dn_against_so(so.name, 6)
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 6)
# Check delivered_qty after make_sales_invoice with update_stock checked
si2 = make_sales_invoice(so.name)
si2.set("update_stock", 1)
si2.get("items")[0].qty = 3
si2.insert()
si2.submit()
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 9)
# Make return deliver note, sales invoice and check quantity
from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
from epaas.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
dn1 = create_delivery_note(is_return=1,
return_against=dn.name,
qty=-3,
do_not_submit=True)
dn1.items[0].against_sales_order = so.name
dn1.items[0].so_detail = so.items[0].name
dn1.submit()
si1 = create_sales_invoice(is_return=1,
return_against=si2.name,
qty=-1,
update_stock=1,
do_not_submit=True)
si1.items[0].sales_order = so.name
si1.items[0].so_detail = so.items[0].name
si1.submit()
so.load_from_db()
self.assertEqual(so.get("items")[0].delivered_qty, 5)
def test_create_quotation_with_margin(self):
from epaas.selling.doctype.quotation.quotation import make_sales_order
from epaas.selling.doctype.sales_order.sales_order \
import make_delivery_note, make_sales_invoice
rate_with_margin = flt((1500 * 18.75) / 100 + 1500)
test_records[0]['items'][0]['price_list_rate'] = 1500
test_records[0]['items'][0]['margin_type'] = 'Percentage'
test_records[0]['items'][0]['margin_rate_or_amount'] = 18.75
quotation = dataent.copy_doc(test_records[0])
quotation.transaction_date = nowdate()
quotation.valid_till = add_months(quotation.transaction_date, 1)
quotation.insert()
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
self.assertRaises(dataent.ValidationError, make_sales_order,
quotation.name)
quotation.submit()
sales_order = make_sales_order(quotation.name)
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = "2016-01-01"
sales_order.delivery_date = "2016-01-02"
sales_order.insert()
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
sales_order.submit()
dn = make_delivery_note(sales_order.name)
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
dn.save()
si = make_sales_invoice(sales_order.name)
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
si.save()
def test_customer_credit_limit(self):
from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
from epaas.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
from epaas.selling.doctype.sales_order.test_sales_order import make_sales_order
from epaas.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:
dataent.db.set_value("Customer", '_Test Customer', 'credit_limit',
outstanding_amt - 50.0)
# Sales Order
so = make_sales_order(do_not_submit=True)
self.assertRaises(dataent.ValidationError, so.submit)
# Delivery Note
dn = create_delivery_note(do_not_submit=True)
self.assertRaises(dataent.ValidationError, dn.submit)
# Sales Invoice
si = create_sales_invoice(do_not_submit=True)
self.assertRaises(dataent.ValidationError, si.submit)
if credit_limit > outstanding_amt:
dataent.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(dataent.ValidationError, make_sales_order)
def test_serial_no_based_delivery(self):
dataent.set_value("Stock Settings", None,
"automatically_set_serial_nos_based_on_fifo", 1)
from epaas.stock.doctype.item.test_item import make_item
item = make_item(
"_Reserved_Serialized_Item", {
"is_stock_item":
1,
"maintain_stock":
1,
"has_serial_no":
1,
"serial_no_series":
"SI.####",
"valuation_rate":
500,
"item_defaults": [{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
dataent.db.sql("""delete from `tabSerial No` where item_code=%s""",
(item.item_code))
make_item(
"_Test Item A", {
"maintain_stock":
1,
"valuation_rate":
100,
"item_defaults": [{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
make_item(
"_Test Item B", {
"maintain_stock":
1,
"valuation_rate":
200,
"item_defaults": [{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
from epaas.manufacturing.doctype.production_plan.test_production_plan import make_bom
make_bom(item=item.item_code,
rate=1000,
raw_materials=['_Test Item A', '_Test Item B'])
so = make_sales_order(
**{
"item_list": [{
"item_code": item.item_code,
"ensure_delivery_based_on_produced_serial_no": 1,
"qty": 1,
"rate": 1000
}]
})
so.submit()
from epaas.manufacturing.doctype.work_order.test_work_order import \
make_wo_order_test_record
work_order = make_wo_order_test_record(item=item.item_code,
qty=1,
do_not_save=True)
work_order.fg_warehouse = "_Test Warehouse - _TC"
work_order.sales_order = so.name
work_order.submit()
make_stock_entry(item_code=item.item_code,
target="_Test Warehouse - _TC",
qty=1)
item_serial_no = dataent.get_doc("Serial No",
{"item_code": item.item_code})
from epaas.manufacturing.doctype.work_order.work_order import \
make_stock_entry as make_production_stock_entry
se = dataent.get_doc(
make_production_stock_entry(work_order.name, "Manufacture", 1))
se.submit()
reserved_serial_no = se.get("items")[2].serial_no
serial_no_so = dataent.get_value("Serial No", reserved_serial_no,
"sales_order")
self.assertEqual(serial_no_so, so.name)
dn = make_delivery_note(so.name)
dn.save()
self.assertEqual(reserved_serial_no, dn.get("items")[0].serial_no)
item_line = dn.get("items")[0]
item_line.serial_no = item_serial_no.name
self.assertRaises(dataent.ValidationError, dn.submit)
item_line = dn.get("items")[0]
item_line.serial_no = reserved_serial_no
self.assertTrue(dn.submit)
dn.load_from_db()
dn.cancel()
si = make_sales_invoice(so.name)
si.update_stock = 1
si.save()
self.assertEqual(si.get("items")[0].serial_no, reserved_serial_no)
item_line = si.get("items")[0]
item_line.serial_no = item_serial_no.name
self.assertRaises(dataent.ValidationError, dn.submit)
item_line = si.get("items")[0]
item_line.serial_no = reserved_serial_no
self.assertTrue(si.submit)
si.submit()
si.load_from_db()
si.cancel()
si = make_sales_invoice(so.name)
si.update_stock = 0
si.submit()
from epaas.accounts.doctype.sales_invoice.sales_invoice import \
make_delivery_note as make_delivery_note_from_invoice
dn = make_delivery_note_from_invoice(si.name)
dn.save()
dn.submit()
self.assertEqual(dn.get("items")[0].serial_no, reserved_serial_no)
dn.load_from_db()
dn.cancel()
si.load_from_db()
si.cancel()
se.load_from_db()
se.cancel()
self.assertFalse(
dataent.db.exists("Serial No", {"sales_order": so.name}))
def test_terms_not_copied(self):
so = make_sales_order()
self.assertTrue(so.get('payment_schedule'))
si = make_sales_invoice(so.name)
self.assertFalse(si.get('payment_schedule'))