def test_purchase_receipt_no_gl_entry(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(0, company)
existing_bin_stock_value = dataent.db.get_value(
"Bin", {
"item_code": "_Test Item",
"warehouse": "_Test Warehouse - _TC"
}, "stock_value")
pr = make_purchase_receipt()
stock_value_difference = dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": pr.name,
"item_code": "_Test Item",
"warehouse": "_Test Warehouse - _TC"
}, "stock_value_difference")
self.assertEqual(stock_value_difference, 250)
current_bin_stock_value = dataent.db.get_value(
"Bin", {
"item_code": "_Test Item",
"warehouse": "_Test Warehouse - _TC"
}, "stock_value")
self.assertEqual(current_bin_stock_value,
existing_bin_stock_value + 250)
self.assertFalse(get_gl_entries("Purchase Receipt", pr.name))
def test_purchase_return(self):
set_perpetual_inventory()
pr = make_purchase_receipt()
return_pr = make_purchase_receipt(is_return=1,
return_against=pr.name,
qty=-2)
# check sle
outgoing_rate = dataent.db.get_value("Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": return_pr.name
}, "outgoing_rate")
self.assertEqual(outgoing_rate, 50)
# check gl entries for return
gl_entries = get_gl_entries("Purchase Receipt", return_pr.name)
self.assertTrue(gl_entries)
stock_in_hand_account = get_inventory_account(return_pr.company)
expected_values = {
stock_in_hand_account: [0.0, 100.0],
"Stock Received But Not Billed - _TC": [100.0, 0.0],
}
for gle in gl_entries:
self.assertEqual(expected_values[gle.account][0], gle.debit)
self.assertEqual(expected_values[gle.account][1], gle.credit)
set_perpetual_inventory(0)
def test_repack_no_change_in_valuation(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(0, company)
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
make_stock_entry(item_code="_Test Item Home Desktop 100",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
repack = dataent.copy_doc(test_records[3])
repack.posting_date = nowdate()
repack.posting_time = nowtime()
repack.insert()
repack.submit()
self.check_stock_ledger_entries(
"Stock Entry", repack.name,
[["_Test Item", "_Test Warehouse - _TC", -50.0],
["_Test Item Home Desktop 100", "_Test Warehouse - _TC", 1]])
gl_entries = dataent.db.sql("""select account, debit, credit
from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s
order by account desc""",
repack.name,
as_dict=1)
self.assertFalse(gl_entries)
set_perpetual_inventory(0, repack.company)
def test_material_receipt_gl_entry(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(1, company)
mr = make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100,
expense_account="Stock Adjustment - _TC")
stock_in_hand_account = get_inventory_account(
mr.company,
mr.get("items")[0].t_warehouse)
self.check_stock_ledger_entries(
"Stock Entry", mr.name,
[["_Test Item", "_Test Warehouse - _TC", 50.0]])
self.check_gl_entries(
"Stock Entry", mr.name,
sorted([[stock_in_hand_account, 5000.0, 0.0],
["Stock Adjustment - _TC", 0.0, 5000.0]]))
mr.cancel()
self.assertFalse(
dataent.db.sql(
"""select * from `tabStock Ledger Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mr.name))
self.assertFalse(
dataent.db.sql(
"""select * from `tabGL Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mr.name))
def test_material_transfer_gl_entry(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(1, company)
create_stock_reconciliation(qty=100, rate=100)
mtn = make_stock_entry(item_code="_Test Item",
source="_Test Warehouse - _TC",
target="_Test Warehouse 1 - _TC",
qty=45)
self.check_stock_ledger_entries(
"Stock Entry", mtn.name,
[["_Test Item", "_Test Warehouse - _TC", -45.0],
["_Test Item", "_Test Warehouse 1 - _TC", 45.0]])
stock_in_hand_account = get_inventory_account(
mtn.company,
mtn.get("items")[0].s_warehouse)
fixed_asset_account = get_inventory_account(
mtn.company,
mtn.get("items")[0].t_warehouse)
if stock_in_hand_account == fixed_asset_account:
# no gl entry as both source and target warehouse has linked to same account.
self.assertFalse(
dataent.db.sql(
"""select * from `tabGL Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name))
else:
stock_value_diff = abs(
dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": mtn.name,
"warehouse": "_Test Warehouse - _TC"
}, "stock_value_difference"))
self.check_gl_entries(
"Stock Entry", mtn.name,
sorted([
[stock_in_hand_account, 0.0, stock_value_diff],
[fixed_asset_account, stock_value_diff, 0.0],
]))
mtn.cancel()
self.assertFalse(
dataent.db.sql(
"""select * from `tabStock Ledger Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name))
self.assertFalse(
dataent.db.sql(
"""select * from `tabGL Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mtn.name))
def test_repack_with_additional_costs(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(1, company)
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100)
repack = dataent.copy_doc(test_records[3])
repack.posting_date = nowdate()
repack.posting_time = nowtime()
repack.set("additional_costs", [
{
"description": "Actual Oerating Cost",
"amount": 1000
},
{
"description": "additional operating costs",
"amount": 200
},
])
repack.insert()
repack.submit()
stock_in_hand_account = get_inventory_account(
repack.company,
repack.get("items")[1].t_warehouse)
rm_stock_value_diff = abs(
dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": repack.name,
"item_code": "_Test Item"
}, "stock_value_difference"))
fg_stock_value_diff = abs(
dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": repack.name,
"item_code": "_Test Item Home Desktop 100"
}, "stock_value_difference"))
stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2)
self.assertEqual(stock_value_diff, 1200)
self.check_gl_entries(
"Stock Entry", repack.name,
sorted([[stock_in_hand_account, 1200, 0.0],
["Expenses Included In Valuation - _TC", 0.0, 1200.0]]))
set_perpetual_inventory(0, repack.company)
def test_warehouse_company_validation(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse 2 - _TC1',
'company')
set_perpetual_inventory(0, company)
dataent.get_doc("User", "*****@*****.**")\
.add_roles("Sales User", "Sales Manager", "Stock User", "Stock Manager")
dataent.set_user("*****@*****.**")
from epaas.stock.utils import InvalidWarehouseCompany
st1 = dataent.copy_doc(test_records[0])
st1.get("items")[0].t_warehouse = "_Test Warehouse 2 - _TC1"
st1.insert()
self.assertRaises(InvalidWarehouseCompany, st1.submit)
def test_warehouse_merging(self):
set_perpetual_inventory(1)
create_warehouse("Test Warehouse for Merging 1")
create_warehouse("Test Warehouse for Merging 2")
make_stock_entry(item_code="_Test Item",
target="Test Warehouse for Merging 1 - _TC",
qty=1,
rate=100)
make_stock_entry(item_code="_Test Item",
target="Test Warehouse for Merging 2 - _TC",
qty=1,
rate=100)
existing_bin_qty = (cint(
dataent.db.get_value(
"Bin", {
"item_code": "_Test Item",
"warehouse": "Test Warehouse for Merging 1 - _TC"
}, "actual_qty")) + cint(
dataent.db.get_value(
"Bin", {
"item_code": "_Test Item",
"warehouse": "Test Warehouse for Merging 2 - _TC"
}, "actual_qty")))
rename_doc("Warehouse",
"Test Warehouse for Merging 1 - _TC",
"Test Warehouse for Merging 2 - _TC",
merge=True)
self.assertFalse(
dataent.db.exists("Warehouse",
"Test Warehouse for Merging 1 - _TC"))
bin_qty = dataent.db.get_value(
"Bin", {
"item_code": "_Test Item",
"warehouse": "Test Warehouse for Merging 2 - _TC"
}, "actual_qty")
self.assertEqual(bin_qty, existing_bin_qty)
self.assertTrue(
dataent.db.get_value(
"Warehouse",
filters={"account": "Test Warehouse for Merging 2 - _TC"}))
def test_material_issue_gl_entry(self):
company = dataent.db.get_value('Warehouse', '_Test Warehouse - _TC',
'company')
set_perpetual_inventory(1, company)
make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100,
expense_account="Stock Adjustment - _TC")
mi = make_stock_entry(item_code="_Test Item",
source="_Test Warehouse - _TC",
qty=40,
expense_account="Stock Adjustment - _TC")
self.check_stock_ledger_entries(
"Stock Entry", mi.name,
[["_Test Item", "_Test Warehouse - _TC", -40.0]])
stock_in_hand_account = get_inventory_account(mi.company,
"_Test Warehouse - _TC")
stock_value_diff = abs(
dataent.db.get_value("Stock Ledger Entry", {
"voucher_type": "Stock Entry",
"voucher_no": mi.name
}, "stock_value_difference"))
self.check_gl_entries(
"Stock Entry", mi.name,
sorted([[stock_in_hand_account, 0.0, stock_value_diff],
["Stock Adjustment - _TC", stock_value_diff, 0.0]]))
mi.cancel()
self.assertFalse(
dataent.db.sql(
"""select name from `tabStock Ledger Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mi.name))
self.assertFalse(
dataent.db.sql(
"""select name from `tabGL Entry`
where voucher_type='Stock Entry' and voucher_no=%s""", mi.name))
def test_purchase_receipt_for_enable_allow_cost_center_in_entry_of_bs_account(
self):
from epaas.accounts.doctype.cost_center.test_cost_center import create_cost_center
accounts_settings = dataent.get_doc('Accounts Settings',
'Accounts Settings')
accounts_settings.allow_cost_center_in_entry_of_bs_account = 1
accounts_settings.save()
cost_center = "_Test Cost Center for BS Account - _TC"
create_cost_center(cost_center_name="_Test Cost Center for BS Account",
company="_Test Company")
if not dataent.db.exists('Location', 'Test Location'):
dataent.get_doc({
'doctype': 'Location',
'location_name': 'Test Location'
}).insert()
set_perpetual_inventory(1, "_Test Company")
pr = make_purchase_receipt(cost_center=cost_center)
stock_in_hand_account = get_inventory_account(
pr.company,
pr.get("items")[0].warehouse)
gl_entries = get_gl_entries("Purchase Receipt", pr.name)
self.assertTrue(gl_entries)
expected_values = {
"Stock Received But Not Billed - _TC": {
"cost_center": cost_center
},
stock_in_hand_account: {
"cost_center": cost_center
}
}
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_values[gle.account]["cost_center"],
gle.cost_center)
set_perpetual_inventory(0, pr.company)
accounts_settings.allow_cost_center_in_entry_of_bs_account = 0
accounts_settings.save()
def test_purchase_return_for_rejected_qty(self):
set_perpetual_inventory()
pr = make_purchase_receipt(received_qty=4, qty=2)
return_pr = make_purchase_receipt(is_return=1,
return_against=pr.name,
received_qty=-4,
qty=-2)
actual_qty = dataent.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": return_pr.name,
'warehouse': return_pr.items[0].rejected_warehouse
}, "actual_qty")
self.assertEqual(actual_qty, -2)
set_perpetual_inventory(0)
def test_purchase_receipt_gl_entry(self):
pr = dataent.copy_doc(test_records[0])
set_perpetual_inventory(1, pr.company)
self.assertEqual(
cint(epaas.is_perpetual_inventory_enabled(pr.company)), 1)
pr.insert()
pr.submit()
gl_entries = get_gl_entries("Purchase Receipt", pr.name)
self.assertTrue(gl_entries)
stock_in_hand_account = get_inventory_account(
pr.company,
pr.get("items")[0].warehouse)
fixed_asset_account = get_inventory_account(
pr.company,
pr.get("items")[1].warehouse)
if stock_in_hand_account == fixed_asset_account:
expected_values = {
stock_in_hand_account: [750.0, 0.0],
"Stock Received But Not Billed - _TC": [0.0, 500.0],
"Expenses Included In Valuation - _TC": [0.0, 250.0]
}
else:
expected_values = {
stock_in_hand_account: [375.0, 0.0],
fixed_asset_account: [375.0, 0.0],
"Stock Received But Not Billed - _TC": [0.0, 500.0],
"Expenses Included In Valuation - _TC": [0.0, 250.0]
}
for gle in gl_entries:
self.assertEqual(expected_values[gle.account][0], gle.debit)
self.assertEqual(expected_values[gle.account][1], gle.credit)
pr.cancel()
self.assertFalse(get_gl_entries("Purchase Receipt", pr.name))
set_perpetual_inventory(0, pr.company)
def test_warehouse_renaming(self):
set_perpetual_inventory(1)
create_warehouse("Test Warehouse for Renaming 1")
account = get_inventory_account("_Test Company",
"Test Warehouse for Renaming 1 - _TC")
self.assertTrue(
dataent.db.get_value("Warehouse", filters={"account": account}))
# Rename with abbr
if dataent.db.exists("Warehouse",
"Test Warehouse for Renaming 2 - _TC"):
dataent.delete_doc("Warehouse",
"Test Warehouse for Renaming 2 - _TC")
rename_doc("Warehouse", "Test Warehouse for Renaming 1 - _TC",
"Test Warehouse for Renaming 2 - _TC")
self.assertTrue(
dataent.db.get_value(
"Warehouse",
filters={"account": "Test Warehouse for Renaming 1 - _TC"}))
# Rename without abbr
if dataent.db.exists("Warehouse",
"Test Warehouse for Renaming 3 - _TC"):
dataent.delete_doc("Warehouse",
"Test Warehouse for Renaming 3 - _TC")
rename_doc("Warehouse", "Test Warehouse for Renaming 2 - _TC",
"Test Warehouse for Renaming 3")
self.assertTrue(
dataent.db.get_value(
"Warehouse",
filters={"account": "Test Warehouse for Renaming 1 - _TC"}))
# Another rename with multiple dashes
if dataent.db.exists("Warehouse", "Test - Warehouse - Company - _TC"):
dataent.delete_doc("Warehouse", "Test - Warehouse - Company - _TC")
rename_doc("Warehouse", "Test Warehouse for Renaming 3 - _TC",
"Test - Warehouse - Company")
def test_warehouse_user(self):
add_user_permission("Warehouse", "_Test Warehouse 1 - _TC",
"*****@*****.**")
add_user_permission("Warehouse", "_Test Warehouse 2 - _TC1",
"*****@*****.**")
add_user_permission("Company", "_Test Company 1", "*****@*****.**")
test_user = dataent.get_doc("User", "*****@*****.**")
test_user.add_roles("Sales User", "Sales Manager", "Stock User")
test_user.remove_roles("Stock Manager", "System Manager")
dataent.get_doc("User", "*****@*****.**")\
.add_roles("Sales User", "Sales Manager", "Stock User", "Stock Manager")
st1 = dataent.copy_doc(test_records[0])
st1.company = "_Test Company 1"
set_perpetual_inventory(0, st1.company)
dataent.set_user("*****@*****.**")
st1.get("items")[0].t_warehouse = "_Test Warehouse 2 - _TC1"
self.assertRaises(dataent.PermissionError, st1.insert)
test_user.add_roles("System Manager")
dataent.set_user("*****@*****.**")
st1 = dataent.copy_doc(test_records[0])
st1.company = "_Test Company 1"
st1.get("items")[0].t_warehouse = "_Test Warehouse 2 - _TC1"
st1.get("items")[0].expense_account = "Stock Adjustment - _TC1"
st1.get("items")[0].cost_center = "Main - _TC1"
st1.insert()
st1.submit()
dataent.set_user("Administrator")
remove_user_permission("Warehouse", "_Test Warehouse 1 - _TC",
"*****@*****.**")
remove_user_permission("Warehouse", "_Test Warehouse 2 - _TC1",
"*****@*****.**")
remove_user_permission("Company", "_Test Company 1",
"*****@*****.**")
def test_gle_for_opening_stock_entry(self):
set_perpetual_inventory(1)
mr = make_stock_entry(item_code="_Test Item",
target="_Test Warehouse - _TC",
qty=50,
basic_rate=100,
expense_account="Stock Adjustment - _TC",
is_opening="Yes",
do_not_save=True)
self.assertRaises(OpeningEntryAccountError, mr.save)
mr.items[0].expense_account = "Temporary Opening - _TC"
mr.save()
mr.submit()
is_opening = dataent.db.get_value("GL Entry",
filters={
"voucher_type": "Stock Entry",
"voucher_no": mr.name
},
fieldname="is_opening")
self.assertEqual(is_opening, "Yes")
def setUp(self):
epaas.set_perpetual_inventory(0)
def tearDown(self):
dataent.set_user("Administrator")
set_perpetual_inventory(0)
