def test_work_order_with_non_transfer_item(self):
items = {
'Finished Good Transfer Item': 1,
'_Test FG Item': 1,
'_Test FG Item 1': 0
}
for item, allow_transfer in items.items():
make_item(item, {'include_item_in_manufacturing': allow_transfer})
fg_item = 'Finished Good Transfer Item'
test_stock_entry.make_stock_entry(item_code="_Test FG Item",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
test_stock_entry.make_stock_entry(item_code="_Test FG Item 1",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
if not dataent.db.get_value('BOM', {'item': fg_item}):
make_bom(item=fg_item,
raw_materials=['_Test FG Item', '_Test FG Item 1'])
wo = make_wo_order_test_record(production_item=fg_item)
ste = dataent.get_doc(
make_stock_entry(wo.name, "Material Transfer for Manufacture", 1))
ste.insert()
ste.submit()
self.assertEqual(len(ste.items), 1)
ste1 = dataent.get_doc(make_stock_entry(wo.name, "Manufacture", 1))
self.assertEqual(len(ste1.items), 3)
def test_create_two_quotations(self):
from epaas.stock.doctype.item.test_item import make_item
first_item = make_item("_Test Laptop", {"is_stock_item": 1})
second_item = make_item("_Test CPU", {"is_stock_item": 1})
qo_item1 = [{
"item_code": first_item.item_code,
"warehouse": "",
"qty": 2,
"rate": 400,
"delivered_by_supplier": 1,
"supplier": '_Test Supplier'
}]
qo_item2 = [{
"item_code": second_item.item_code,
"warehouse": "_Test Warehouse - _TC",
"qty": 2,
"rate": 300,
"conversion_factor": 1.0
}]
first_qo = make_quotation(item_list=qo_item1, do_not_submit=True)
first_qo.submit()
sec_qo = make_quotation(item_list=qo_item2, do_not_submit=True)
sec_qo.submit()
def make_serialized_item():
asset_item = "Test Serialized Asset Item"
if not dataent.db.exists('Item', asset_item):
asset_category = dataent.get_all('Asset Category')
if asset_category:
asset_category = asset_category[0].name
if not asset_category:
doc = dataent.get_doc({
'doctype': 'Asset Category',
'asset_category_name': 'Test Asset Category',
'depreciation_method': 'Straight Line',
'total_number_of_depreciations': 12,
'frequency_of_depreciation': 1,
'accounts': [{
'company_name': '_Test Company',
'fixed_asset_account': '_Test Fixed Asset - _TC',
'accumulated_depreciation_account': 'Depreciation - _TC',
'depreciation_expense_account': 'Depreciation - _TC'
}]
}).insert()
asset_category = doc.name
make_item(asset_item, {'is_stock_item':0,
'stock_uom': 'Box', 'is_fixed_asset': 1, 'has_serial_no': 1,
'asset_category': asset_category, 'serial_no_series': 'ABC.###'})
def test_auto_insert_price(self):
from epaas.stock.doctype.item.test_item import make_item
make_item("_Test Item for Auto Price List", {"is_stock_item": 0})
dataent.db.set_value("Stock Settings", None,
"auto_insert_price_list_rate_if_missing", 1)
item_price = dataent.db.get_value(
"Item Price", {
"price_list": "_Test Price List",
"item_code": "_Test Item for Auto Price List"
})
if item_price:
dataent.delete_doc("Item Price", item_price)
make_sales_order(item_code="_Test Item for Auto Price List",
selling_price_list="_Test Price List",
rate=100)
self.assertEqual(
dataent.db.get_value(
"Item Price", {
"price_list": "_Test Price List",
"item_code": "_Test Item for Auto Price List"
}, "price_list_rate"), 100)
# do not update price list
dataent.db.set_value("Stock Settings", None,
"auto_insert_price_list_rate_if_missing", 0)
item_price = dataent.db.get_value(
"Item Price", {
"price_list": "_Test Price List",
"item_code": "_Test Item for Auto Price List"
})
if item_price:
dataent.delete_doc("Item Price", item_price)
make_sales_order(item_code="_Test Item for Auto Price List",
selling_price_list="_Test Price List",
rate=100)
self.assertEqual(
dataent.db.get_value(
"Item Price", {
"price_list": "_Test Price List",
"item_code": "_Test Item for Auto Price List"
}, "price_list_rate"), None)
dataent.db.set_value("Stock Settings", None,
"auto_insert_price_list_rate_if_missing", 1)
def test_not_accept_duplicate_serial_no(self):
from epaas.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
item_code = dataent.db.get_value('Item', {
'has_serial_no': 1,
'is_fixed_asset': 0
})
if not item_code:
item = make_item("Test Serial Item 1", dict(has_serial_no=1))
item_code = item.name
serial_no = random_string(5)
make_purchase_receipt(item_code=item_code, qty=1, serial_no=serial_no)
create_delivery_note(item_code=item_code, qty=1, serial_no=serial_no)
pr = make_purchase_receipt(item_code=item_code,
qty=1,
serial_no=serial_no,
do_not_submit=True)
self.assertRaises(SerialNoDuplicateError, pr.submit)
se = make_stock_entry(item_code=item_code,
target="_Test Warehouse - _TC",
qty=1,
serial_no=serial_no,
basic_rate=100,
do_not_submit=True)
self.assertRaises(SerialNoDuplicateError, se.submit)
def test_work_order_with_non_stock_item(self):
items = {
'Finished Good Test Item For non stock': 1,
'_Test FG Item': 1,
'_Test FG Non Stock Item': 0
}
for item, is_stock_item in items.items():
make_item(item, {'is_stock_item': is_stock_item})
if not dataent.db.get_value('Item Price',
{'item_code': '_Test FG Non Stock Item'}):
dataent.get_doc({
'doctype': 'Item Price',
'item_code': '_Test FG Non Stock Item',
'price_list_rate': 1000,
'price_list': 'Standard Buying'
}).insert(ignore_permissions=True)
fg_item = 'Finished Good Test Item For non stock'
test_stock_entry.make_stock_entry(item_code="_Test FG Item",
target="_Test Warehouse - _TC",
qty=1,
basic_rate=100)
if not dataent.db.get_value('BOM', {'item': fg_item}):
make_bom(
item=fg_item,
rate=1000,
raw_materials=['_Test FG Item', '_Test FG Non Stock Item'])
wo = make_wo_order_test_record(production_item=fg_item)
se = dataent.get_doc(
make_stock_entry(wo.name, "Material Transfer for Manufacture", 1))
se.insert()
se.submit()
ste = dataent.get_doc(make_stock_entry(wo.name, "Manufacture", 1))
ste.insert()
self.assertEqual(len(ste.additional_costs), 1)
self.assertEqual(ste.total_additional_costs, 1000)
def test_mix_type_product_bundle(self):
from epaas.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
from epaas.stock.doctype.item.test_item import make_item
make_item("_Test Mix Product Bundle", {"is_stock_item": 0})
make_item("_Test Mix Product Bundle Item 1", {"is_stock_item": 1})
make_item("_Test Mix Product Bundle Item 2", {"is_stock_item": 0})
make_product_bundle("_Test Mix Product Bundle", [
"_Test Mix Product Bundle Item 1",
"_Test Mix Product Bundle Item 2"
])
self.assertRaises(WarehouseRequired,
make_sales_order,
item_code="_Test Mix Product Bundle",
warehouse="")
def test_purchase_return_for_multi_uom(self):
item_code = "_Test Purchase Return For Multi-UOM"
if not dataent.db.exists('Item', item_code):
item = make_item(item_code, {'stock_uom': 'Box'})
row = item.append('uoms', {
'uom': 'Unit',
'conversion_factor': 0.1
})
row.db_update()
pr = make_purchase_receipt(item_code=item_code,
qty=1,
uom="Box",
conversion_factor=1.0)
return_pr = make_purchase_receipt(item_code=item_code,
qty=-10,
uom="Unit",
stock_uom="Box",
conversion_factor=0.1,
is_return=1,
return_against=pr.name)
self.assertEqual(abs(return_pr.items[0].stock_qty), 1.0)
def make_subcontracted_item(item_code):
from epaas.manufacturing.doctype.production_plan.test_production_plan import make_bom
if not dataent.db.exists('Item', item_code):
make_item(item_code, {'is_stock_item': 1, 'is_sub_contracted_item': 1})
if not dataent.db.exists('Item', "Test Extra Item 1"):
make_item("Test Extra Item 1", {
'is_stock_item': 1,
})
if not dataent.db.exists('Item', "Test Extra Item 2"):
make_item("Test Extra Item 2", {
'is_stock_item': 1,
})
if not dataent.db.get_value('BOM', {'item': item_code}, 'name'):
make_bom(item=item_code,
raw_materials=['_Test FG Item', 'Test Extra Item 1'])
def test_service_type_product_bundle(self):
from epaas.selling.doctype.product_bundle.test_product_bundle import make_product_bundle
from epaas.stock.doctype.item.test_item import make_item
make_item("_Test Service Product Bundle", {"is_stock_item": 0})
make_item("_Test Service Product Bundle Item 1", {"is_stock_item": 0})
make_item("_Test Service Product Bundle Item 2", {"is_stock_item": 0})
make_product_bundle("_Test Service Product Bundle", [
"_Test Service Product Bundle Item 1",
"_Test Service Product Bundle Item 2"
])
so = make_sales_order(item_code="_Test Service Product Bundle",
warehouse=None)
self.assertTrue("_Test Service Product Bundle Item 1" in
[d.item_code for d in so.packed_items])
self.assertTrue("_Test Service Product Bundle Item 2" in
[d.item_code for d in so.packed_items])
def test_serialized_asset_item(self):
asset_item = "Test Serialized Asset Item"
if not dataent.db.exists('Item', asset_item):
asset_category = dataent.get_all('Asset Category')
if asset_category:
asset_category = asset_category[0].name
if not asset_category:
doc = dataent.get_doc({
'doctype':
'Asset Category',
'asset_category_name':
'Test Asset Category',
'depreciation_method':
'Straight Line',
'total_number_of_depreciations':
12,
'frequency_of_depreciation':
1,
'accounts': [{
'company_name':
'_Test Company',
'fixed_asset_account':
'_Test Fixed Asset - _TC',
'accumulated_depreciation_account':
'Depreciation - _TC',
'depreciation_expense_account':
'Depreciation - _TC'
}]
}).insert()
asset_category = doc.name
item_data = make_item(
asset_item, {
'is_stock_item': 0,
'stock_uom': 'Box',
'is_fixed_asset': 1,
'has_serial_no': 1,
'asset_category': asset_category,
'serial_no_series': 'ABC.###'
})
asset_item = item_data.item_code
pr = make_purchase_receipt(item_code=asset_item, qty=3)
asset = dataent.db.get_value('Asset', {'purchase_receipt': pr.name},
'name')
asset_movement = dataent.db.get_value('Asset Movement',
{'reference_name': pr.name},
'name')
serial_nos = dataent.get_all('Serial No', {'asset': asset}, 'name')
self.assertEquals(len(serial_nos), 3)
location = dataent.db.get_value('Serial No', serial_nos[0].name,
'location')
self.assertEquals(location, "Test Location")
pr.cancel()
serial_nos = dataent.get_all('Serial No', {'asset': asset},
'name') or []
self.assertEquals(len(serial_nos), 0)
#dataent.db.sql("delete from `tabLocation")
dataent.db.sql("delete from `tabAsset`")
def test_request_for_raw_materials(self):
from epaas.stock.doctype.item.test_item import make_item
item = make_item(
"_Test Finished Item", {
"is_stock_item":
1,
"maintain_stock":
1,
"valuation_rate":
500,
"item_defaults": [{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
make_item(
"_Test Raw Item A", {
"maintain_stock":
1,
"valuation_rate":
100,
"item_defaults": [{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
make_item(
"_Test Raw 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 Raw Item A', '_Test Raw Item B'])
so = make_sales_order(**{
"item_list": [{
"item_code": item.item_code,
"qty": 1,
"rate": 1000
}]
})
so.submit()
mr_dict = dataent._dict()
items = so.get_work_order_items(1)
mr_dict['items'] = items
mr_dict['include_exploded_items'] = 0
mr_dict['ignore_existing_ordered_qty'] = 1
make_raw_material_request(mr_dict, so.company, so.name)
mr = dataent.db.sql(
"""select name from `tabMaterial Request` ORDER BY creation DESC LIMIT 1""",
as_dict=1)[0]
mr_doc = dataent.get_doc('Material Request', mr.get('name'))
self.assertEqual(mr_doc.items[0].sales_order, so.name)
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_drop_shipping(self):
from epaas.selling.doctype.sales_order.sales_order import make_purchase_order_for_drop_shipment
from epaas.buying.doctype.purchase_order.purchase_order import update_status
make_stock_entry(target="_Test Warehouse - _TC", qty=10, rate=100)
from epaas.stock.doctype.item.test_item import make_item
po_item = make_item("_Test Item for Drop Shipping", {
"is_stock_item": 1,
"delivered_by_supplier": 1
})
dn_item = make_item("_Test Regular Item", {"is_stock_item": 1})
so_items = [{
"item_code": po_item.item_code,
"warehouse": "",
"qty": 2,
"rate": 400,
"delivered_by_supplier": 1,
"supplier": '_Test Supplier'
}, {
"item_code": dn_item.item_code,
"warehouse": "_Test Warehouse - _TC",
"qty": 2,
"rate": 300,
"conversion_factor": 1.0
}]
if dataent.db.get_value("Item", "_Test Regular Item",
"is_stock_item") == 1:
make_stock_entry(item="_Test Regular Item",
target="_Test Warehouse - _TC",
qty=10,
rate=100)
#setuo existing qty from bin
bin = dataent.get_all("Bin",
filters={
"item_code": po_item.item_code,
"warehouse": "_Test Warehouse - _TC"
},
fields=["ordered_qty", "reserved_qty"])
existing_ordered_qty = bin[0].ordered_qty if bin else 0.0
existing_reserved_qty = bin[0].reserved_qty if bin else 0.0
bin = dataent.get_all("Bin",
filters={
"item_code": dn_item.item_code,
"warehouse": "_Test Warehouse - _TC"
},
fields=["reserved_qty"])
existing_reserved_qty_for_dn_item = bin[0].reserved_qty if bin else 0.0
#create so, po and partial dn
so = make_sales_order(item_list=so_items, do_not_submit=True)
so.submit()
po = make_purchase_order_for_drop_shipment(so.name, '_Test Supplier')
po.submit()
dn = create_dn_against_so(so.name, delivered_qty=1)
self.assertEqual(so.customer, po.customer)
self.assertEqual(po.items[0].sales_order, so.name)
self.assertEqual(po.items[0].item_code, po_item.item_code)
self.assertEqual(dn.items[0].item_code, dn_item.item_code)
#test ordered_qty and reserved_qty
bin = dataent.get_all("Bin",
filters={
"item_code": po_item.item_code,
"warehouse": "_Test Warehouse - _TC"
},
fields=["ordered_qty", "reserved_qty"])
ordered_qty = bin[0].ordered_qty if bin else 0.0
reserved_qty = bin[0].reserved_qty if bin else 0.0
self.assertEqual(abs(flt(ordered_qty)), existing_ordered_qty)
self.assertEqual(abs(flt(reserved_qty)), existing_reserved_qty)
reserved_qty = dataent.db.get_value(
"Bin", {
"item_code": dn_item.item_code,
"warehouse": "_Test Warehouse - _TC"
}, "reserved_qty")
self.assertEqual(abs(flt(reserved_qty)),
existing_reserved_qty_for_dn_item + 1)
#test po_item length
self.assertEqual(len(po.items), 1)
#test per_delivered status
update_status("Delivered", po.name)
self.assertEqual(
flt(dataent.db.get_value("Sales Order", so.name, "per_delivered"),
2), 75.00)
#test reserved qty after complete delivery
dn = create_dn_against_so(so.name, delivered_qty=1)
reserved_qty = dataent.db.get_value(
"Bin", {
"item_code": dn_item.item_code,
"warehouse": "_Test Warehouse - _TC"
}, "reserved_qty")
self.assertEqual(abs(flt(reserved_qty)),
existing_reserved_qty_for_dn_item)
#test after closing so
so.db_set('status', "Closed")
so.update_reserved_qty()
bin = dataent.get_all("Bin",
filters={
"item_code": po_item.item_code,
"warehouse": "_Test Warehouse - _TC"
},
fields=["ordered_qty", "reserved_qty"])
ordered_qty = bin[0].ordered_qty if bin else 0.0
reserved_qty = bin[0].reserved_qty if bin else 0.0
self.assertEqual(abs(flt(ordered_qty)), existing_ordered_qty)
self.assertEqual(abs(flt(reserved_qty)), existing_reserved_qty)
reserved_qty = dataent.db.get_value(
"Bin", {
"item_code": dn_item.item_code,
"warehouse": "_Test Warehouse - _TC"
}, "reserved_qty")
self.assertEqual(abs(flt(reserved_qty)),
existing_reserved_qty_for_dn_item)
def make_batch_item(cls, item_name):
from epaas.stock.doctype.item.test_item import make_item
if not dataent.db.exists(item_name):
return make_item(
item_name,
dict(has_batch_no=1, create_new_batch=1, is_stock_item=1))