def test_merging_with_validate_selling_price(self):
from erpbee.accounts.doctype.pos_closing_entry.test_pos_closing_entry import init_user_and_profile
from erpbee.accounts.doctype.pos_invoice_merge_log.pos_invoice_merge_log import merge_pos_invoices
if not frappe.db.get_single_value("Selling Settings",
"validate_selling_price"):
frappe.db.set_value("Selling Settings", "Selling Settings",
"validate_selling_price", 1)
make_purchase_receipt(item_code="_Test Item",
warehouse="_Test Warehouse - _TC",
qty=1,
rate=300)
frappe.db.sql("delete from `tabPOS Invoice`")
test_user, pos_profile = init_user_and_profile()
pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
pos_inv.append('payments', {
'mode_of_payment': 'Cash',
'account': 'Cash - _TC',
'amount': 300
})
pos_inv.append(
'taxes', {
"charge_type": "On Net Total",
"account_head": "_Test Account Service Tax - _TC",
"cost_center": "_Test Cost Center - _TC",
"description": "Service Tax",
"rate": 14,
'included_in_print_rate': 1
})
self.assertRaises(frappe.ValidationError, pos_inv.submit)
pos_inv2 = create_pos_invoice(rate=400, do_not_submit=1)
pos_inv2.append('payments', {
'mode_of_payment': 'Cash',
'account': 'Cash - _TC',
'amount': 400
})
pos_inv2.append(
'taxes', {
"charge_type": "On Net Total",
"account_head": "_Test Account Service Tax - _TC",
"cost_center": "_Test Cost Center - _TC",
"description": "Service Tax",
"rate": 14,
'included_in_print_rate': 1
})
pos_inv2.submit()
merge_pos_invoices()
pos_inv2.load_from_db()
rounded_total = frappe.db.get_value("Sales Invoice",
pos_inv2.consolidated_invoice,
"rounded_total")
self.assertEqual(rounded_total, 400)
frappe.set_user("Administrator")
frappe.db.set_value("Selling Settings", "Selling Settings",
"validate_selling_price", 0)
def test_sub_contracted_item_costing(self):
from erpbee.manufacturing.doctype.production_plan.test_production_plan import make_bom
company = "_Test Company"
rm_item_code = "_Test Item for Reposting"
subcontracted_item = "_Test Subcontracted Item for Reposting"
frappe.db.set_value("Buying Settings", None,
"backflush_raw_materials_of_subcontract_based_on",
"BOM")
make_bom(item=subcontracted_item,
raw_materials=[rm_item_code],
currency="INR")
# Purchase raw materials on supplier warehouse: Qty = 50, Rate = 100
pr = make_purchase_receipt(company=company,
posting_date='2020-04-10',
warehouse="Stores - _TC",
item_code=rm_item_code,
qty=10,
rate=100)
# Purchase Receipt for subcontracted item
pr1 = make_purchase_receipt(company=company,
posting_date='2020-04-20',
warehouse="Finished Goods - _TC",
supplier_warehouse="Stores - _TC",
item_code=subcontracted_item,
qty=10,
rate=20,
is_subcontracted="Yes")
self.assertEqual(pr1.items[0].valuation_rate, 120)
# Update raw material's valuation via LCV, Additional cost = 50
lcv = create_landed_cost_voucher("Purchase Receipt", pr.name,
pr.company)
pr1.reload()
self.assertEqual(pr1.items[0].valuation_rate, 125)
# check outgoing_rate for DN after reposting
incoming_rate = frappe.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": pr1.name,
"item_code": subcontracted_item
}, "incoming_rate")
self.assertEqual(incoming_rate, 125)
# cleanup data
pr1.cancel()
lcv.cancel()
pr.cancel()
def test_pick_list_for_batched_and_serialised_item(self):
# check if oldest batch no and serial nos are picked
item = frappe.db.exists("Item",
{'item_name': 'Batched and Serialised Item'})
if not item:
item = create_item("Batched and Serialised Item")
item.has_batch_no = 1
item.create_new_batch = 1
item.has_serial_no = 1
item.batch_number_series = "B-BATCH-.##"
item.serial_no_series = "S-.####"
item.save()
else:
item = frappe.get_doc("Item",
{'item_name': 'Batched and Serialised Item'})
pr1 = make_purchase_receipt(item_code="Batched and Serialised Item",
qty=2,
rate=100.0)
pr1.load_from_db()
oldest_batch_no = pr1.items[0].batch_no
oldest_serial_nos = pr1.items[0].serial_no
pr2 = make_purchase_receipt(item_code="Batched and Serialised Item",
qty=2,
rate=100.0)
pick_list = frappe.get_doc({
'doctype':
'Pick List',
'company':
'_Test Company',
'purpose':
'Material Transfer',
'locations': [{
'item_code': 'Batched and Serialised Item',
'qty': 2,
'stock_qty': 2,
'conversion_factor': 1,
}]
})
pick_list.set_item_locations()
self.assertEqual(pick_list.locations[0].batch_no, oldest_batch_no)
self.assertEqual(pick_list.locations[0].serial_no, oldest_serial_nos)
pr1.cancel()
pr2.cancel()
def test_last_movement_cancellation(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"next_depreciation_date": "2020-12-31",
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10
})
if asset.docstatus == 0:
asset.submit()
if not frappe.db.exists("Location", "Test Location 2"):
frappe.get_doc({
'doctype': 'Location',
'location_name': 'Test Location 2'
}).insert()
movement = frappe.get_doc({'doctype': 'Asset Movement', 'reference_name': pr.name })
self.assertRaises(frappe.ValidationError, movement.cancel)
movement1 = create_asset_movement(purpose = 'Transfer', company = asset.company,
assets = [{ 'asset': asset.name , 'source_location': 'Test Location', 'target_location': 'Test Location 2'}],
reference_doctype = 'Purchase Receipt', reference_name = pr.name)
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2")
movement1.cancel()
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
def test_create_asset_maintenance(self):
pr = make_purchase_receipt(item_code="Photocopier",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.save()
if not frappe.db.exists("Asset Maintenance", "Photocopier"):
asset_maintenance = frappe.get_doc({
"doctype": "Asset Maintenance",
"asset_name": "Photocopier",
"maintenance_team": "Team Awesome",
"company": "_Test Company",
"asset_maintenance_tasks": get_maintenance_tasks()
}).insert()
next_due_date = calculate_next_due_date(nowdate(), "Monthly")
self.assertEqual(asset_maintenance.asset_maintenance_tasks[0].next_due_date, next_due_date)
def test_asset_expected_value_after_useful_life(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10
})
asset.insert()
accumulated_depreciation_after_full_schedule = \
max([d.accumulated_depreciation_amount for d in asset.get("schedules")])
asset_value_after_full_schedule = (
flt(asset.gross_purchase_amount) -
flt(accumulated_depreciation_after_full_schedule))
self.assertTrue(asset.finance_books[0].expected_value_after_useful_life
>= asset_value_after_full_schedule)
def test_gl_entries_with_perpetual_inventory_against_pr(self):
pr = make_purchase_receipt(
company="_Test Company with perpetual inventory",
supplier_warehouse="Work In Progress - TCP1",
warehouse="Stores - TCP1",
cost_center="Main - TCP1",
get_taxes_and_charges=True,
)
pi = make_purchase_invoice(
company="_Test Company with perpetual inventory",
supplier_warehouse="Work In Progress - TCP1",
warehouse="Stores - TCP1",
cost_center="Main - TCP1",
expense_account="_Test Account Cost for Goods Sold - TCP1",
get_taxes_and_charges=True,
qty=10,
do_not_save="True")
for d in pi.items:
d.purchase_receipt = pr.name
pi.insert()
pi.submit()
pi.load_from_db()
self.assertTrue(pi.status, "Unpaid")
self.check_gle_for_pi(pi.name)
def test_depreciation_entry_cancellation(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": "2020-12-31"
})
asset.insert()
asset.submit()
post_depreciation_entries(date="2021-01-01")
asset.load_from_db()
# cancel depreciation entry
depr_entry = asset.get("schedules")[0].journal_entry
self.assertTrue(depr_entry)
frappe.get_doc("Journal Entry", depr_entry).cancel()
asset.load_from_db()
depr_entry = asset.get("schedules")[0].journal_entry
self.assertFalse(depr_entry)
def test_schedule_for_straight_line_method(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2030-01-01'
asset.purchase_date = '2030-01-01'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 12,
"depreciation_start_date": "2030-12-31"
})
asset.save()
self.assertEqual(asset.status, "Draft")
expected_schedules = [["2030-12-31", 30000.00, 30000.00],
["2031-12-31", 30000.00, 60000.00],
["2032-12-31", 30000.00, 90000.00]]
schedules = [[
cstr(d.schedule_date), d.depreciation_amount,
d.accumulated_depreciation_amount
] for d in asset.get("schedules")]
self.assertEqual(schedules, expected_schedules)
def test_landed_cost_voucher(self):
frappe.db.set_value("Buying Settings", None, "allow_multiple_items", 1)
pr = make_purchase_receipt(company="_Test Company with perpetual inventory",
warehouse = "Stores - TCP1", supplier_warehouse = "Work in Progress - TCP1",
get_multiple_items = True, get_taxes_and_charges = True)
last_sle = frappe.db.get_value("Stock Ledger Entry", {
"voucher_type": pr.doctype,
"voucher_no": pr.name,
"item_code": "_Test Item",
"warehouse": "Stores - TCP1"
},
fieldname=["qty_after_transaction", "stock_value"], as_dict=1)
create_landed_cost_voucher("Purchase Receipt", pr.name, pr.company)
pr_lc_value = frappe.db.get_value("Purchase Receipt Item", {"parent": pr.name}, "landed_cost_voucher_amount")
self.assertEqual(pr_lc_value, 25.0)
last_sle_after_landed_cost = frappe.db.get_value("Stock Ledger Entry", {
"voucher_type": pr.doctype,
"voucher_no": pr.name,
"item_code": "_Test Item",
"warehouse": "Stores - TCP1"
},
fieldname=["qty_after_transaction", "stock_value"], as_dict=1)
self.assertEqual(last_sle.qty_after_transaction, last_sle_after_landed_cost.qty_after_transaction)
self.assertEqual(last_sle_after_landed_cost.stock_value - last_sle.stock_value, 25.0)
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: [800.0, 0.0],
"Stock Received But Not Billed - TCP1": [0.0, 500.0],
"Expenses Included In Valuation - TCP1": [0.0, 50.0],
"_Test Account Customs Duty - TCP1": [0.0, 150],
"_Test Account Shipping Charges - TCP1": [0.0, 100.00]
}
else:
expected_values = {
stock_in_hand_account: [400.0, 0.0],
fixed_asset_account: [400.0, 0.0],
"Stock Received But Not Billed - TCP1": [0.0, 500.0],
"Expenses Included In Valuation - TCP1": [0.0, 300.0]
}
for gle in gl_entries:
if not gle.get('is_cancelled'):
self.assertEqual(expected_values[gle.account][0], gle.debit)
self.assertEqual(expected_values[gle.account][1], gle.credit)
def test_expense_head(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=2,
rate=200000.0,
location="Test Location")
doc = make_invoice(pr.name)
self.assertEquals('Asset Received But Not Billed - _TC',
doc.items[0].expense_account)
def test_purchase_asset(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(
nowdate(), -15)
asset.available_for_use_date = purchase_date
asset.purchase_date = purchase_date
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset.submit()
pi = make_invoice(pr.name)
pi.supplier = "_Test Supplier"
pi.insert()
pi.submit()
asset.load_from_db()
self.assertEqual(asset.supplier, "_Test Supplier")
self.assertEqual(asset.purchase_date, getdate(purchase_date))
# Asset won't have reference to PI when purchased through PR
self.assertEqual(asset.purchase_receipt, pr.name)
expected_gle = (("Asset Received But Not Billed - _TC", 100000.0, 0.0),
("Creditors - _TC", 0.0, 100000.0))
gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Purchase Invoice' and voucher_no = %s
order by account""", pi.name)
self.assertEqual(gle, expected_gle)
pi.cancel()
asset.cancel()
asset.load_from_db()
pr.load_from_db()
pr.cancel()
self.assertEqual(asset.docstatus, 2)
def test_inter_company_transfer(self):
se = make_serialized_item(target_warehouse="_Test Warehouse - _TC")
serial_nos = get_serial_nos(se.get("items")[0].serial_no)
create_delivery_note(item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0])
wh = create_warehouse("_Test Warehouse", company="_Test Company 1")
make_purchase_receipt(item_code="_Test Serialized Item With Series",
qty=1,
serial_no=serial_nos[0],
company="_Test Company 1",
warehouse=wh)
serial_no = frappe.db.get_value("Serial No",
serial_nos[0],
["warehouse", "company"],
as_dict=1)
self.assertEqual(serial_no.warehouse, wh)
self.assertEqual(serial_no.company, "_Test Company 1")
def test_asset_sale(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": "2020-12-31"
})
asset.insert()
asset.submit()
post_depreciation_entries(date="2021-01-01")
si = make_sales_invoice(asset=asset.name,
item_code="Macbook Pro",
company="_Test Company")
si.customer = "_Test Customer"
si.due_date = nowdate()
si.get("items")[0].rate = 25000
si.insert()
si.submit()
self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"),
"Sold")
expected_gle = (("_Test Accumulated Depreciations - _TC", 20392.16,
0.0), ("_Test Fixed Asset - _TC", 0.0, 100000.0),
("_Test Gain/Loss on Asset Disposal - _TC", 54607.84,
0.0), ("Debtors - _TC", 25000.0, 0.0))
gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Sales Invoice' and voucher_no = %s
order by account""", si.name)
self.assertEqual(gle, expected_gle)
si.cancel()
self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"),
"Partially Depreciated")
def test_purchase_return_valuation_reposting(self):
pr = make_purchase_receipt(company="_Test Company",
posting_date='2020-04-10',
warehouse="Stores - _TC",
item_code="_Test Item for Reposting",
qty=5,
rate=100)
return_pr = make_purchase_receipt(company="_Test Company",
posting_date='2020-04-15',
warehouse="Stores - _TC",
item_code="_Test Item for Reposting",
is_return=1,
return_against=pr.name,
qty=-2)
# check sle
outgoing_rate, stock_value_difference = frappe.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": return_pr.name
}, ["outgoing_rate", "stock_value_difference"])
self.assertEqual(outgoing_rate, 100)
self.assertEqual(stock_value_difference, -200)
create_landed_cost_voucher("Purchase Receipt", pr.name, pr.company)
outgoing_rate, stock_value_difference = frappe.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Purchase Receipt",
"voucher_no": return_pr.name
}, ["outgoing_rate", "stock_value_difference"])
self.assertEqual(outgoing_rate, 110)
self.assertEqual(stock_value_difference, -220)
def test_movement(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"next_depreciation_date": "2020-12-31",
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10
})
if asset.docstatus == 0:
asset.submit()
# check asset movement is created
if not frappe.db.exists("Location", "Test Location 2"):
frappe.get_doc({
'doctype': 'Location',
'location_name': 'Test Location 2'
}).insert()
movement1 = create_asset_movement(purpose = 'Transfer', company = asset.company,
assets = [{ 'asset': asset.name , 'source_location': 'Test Location', 'target_location': 'Test Location 2'}],
reference_doctype = 'Purchase Receipt', reference_name = pr.name)
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2")
movement2 = create_asset_movement(purpose = 'Transfer', company = asset.company,
assets = [{ 'asset': asset.name , 'source_location': 'Test Location 2', 'target_location': 'Test Location'}],
reference_doctype = 'Purchase Receipt', reference_name = pr.name)
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
movement1.cancel()
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
employee = make_employee("*****@*****.**", company="_Test Company")
movement3 = create_asset_movement(purpose = 'Issue', company = asset.company,
assets = [{ 'asset': asset.name , 'source_location': 'Test Location', 'to_employee': employee}],
reference_doctype = 'Purchase Receipt', reference_name = pr.name)
# after issuing asset should belong to an employee not at a location
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), None)
self.assertEqual(frappe.db.get_value("Asset", asset.name, "custodian"), employee)
def test_scrap_asset(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-01-01'
asset.purchase_date = '2020-01-01'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 10,
"frequency_of_depreciation": 1
})
asset.insert()
asset.submit()
post_depreciation_entries(date=add_months('2020-01-01', 4))
scrap_asset(asset.name)
asset.load_from_db()
self.assertEqual(asset.status, "Scrapped")
self.assertTrue(asset.journal_entry_for_scrap)
expected_gle = (("_Test Accumulated Depreciations - _TC", 36000.0,
0.0), ("_Test Fixed Asset - _TC", 0.0, 100000.0),
("_Test Gain/Loss on Asset Disposal - _TC", 64000.0,
0.0))
gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Journal Entry' and voucher_no = %s
order by account""", asset.journal_entry_for_scrap)
self.assertEqual(gle, expected_gle)
restore_asset(asset.name)
asset.load_from_db()
self.assertFalse(asset.journal_entry_for_scrap)
self.assertEqual(asset.status, "Partially Depreciated")
def test_landed_cost_voucher_for_odd_numbers (self):
pr = make_purchase_receipt(company="_Test Company with perpetual inventory", warehouse = "Stores - TCP1", supplier_warehouse = "Work in Progress - TCP1", do_not_save=True)
pr.items[0].cost_center = "Main - TCP1"
for x in range(2):
pr.append("items", {
"item_code": "_Test Item",
"warehouse": "Stores - TCP1",
"cost_center": "Main - TCP1",
"qty": 5,
"rate": 50
})
pr.submit()
lcv = create_landed_cost_voucher("Purchase Receipt", pr.name, pr.company, 123.22)
self.assertEqual(lcv.items[0].applicable_charges, 41.07)
self.assertEqual(lcv.items[2].applicable_charges, 41.08)
def test_depreciation(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=100000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.purchase_date = '2020-01-30'
asset.available_for_use_date = "2020-01-30"
asset.append(
"finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": "2020-12-31"
})
asset.insert()
asset.submit()
asset.load_from_db()
self.assertEqual(asset.status, "Submitted")
frappe.db.set_value("Company", "_Test Company",
"series_for_depreciation_entry", "DEPR-")
post_depreciation_entries(date="2021-01-01")
asset.load_from_db()
# check depreciation entry series
self.assertEqual(asset.get("schedules")[0].journal_entry[:4], "DEPR")
expected_gle = (("_Test Accumulated Depreciations - _TC", 0.0,
30000.0), ("_Test Depreciations - _TC", 30000.0, 0.0))
gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where against_voucher_type='Asset' and against_voucher = %s
order by account""", asset.name)
self.assertEqual(gle, expected_gle)
self.assertEqual(asset.get("value_after_depreciation"), 0)
def test_landed_cost_voucher_for_serialized_item(self):
frappe.db.sql("delete from `tabSerial No` where name in ('SN001', 'SN002', 'SN003', 'SN004', 'SN005')")
pr = make_purchase_receipt(company="_Test Company with perpetual inventory", warehouse = "Stores - TCP1",
supplier_warehouse = "Work in Progress - TCP1", get_multiple_items = True,
get_taxes_and_charges = True, do_not_submit = True)
pr.items[0].item_code = "_Test Serialized Item"
pr.items[0].serial_no = "SN001\nSN002\nSN003\nSN004\nSN005"
pr.submit()
serial_no_rate = frappe.db.get_value("Serial No", "SN001", "purchase_rate")
create_landed_cost_voucher("Purchase Receipt", pr.name, pr.company)
serial_no = frappe.db.get_value("Serial No", "SN001",
["warehouse", "purchase_rate"], as_dict=1)
self.assertEqual(serial_no.purchase_rate - serial_no_rate, 5.0)
self.assertEqual(serial_no.warehouse, "Stores - TCP1")
def test_multiple_landed_cost_voucher_against_pr(self):
pr = make_purchase_receipt(company="_Test Company with perpetual inventory", warehouse = "Stores - TCP1",
supplier_warehouse = "Stores - TCP1", do_not_save=True)
pr.append("items", {
"item_code": "_Test Item",
"warehouse": "Stores - TCP1",
"cost_center": "Main - TCP1",
"qty": 5,
"rate": 100
})
pr.submit()
lcv1 = make_landed_cost_voucher(company = pr.company, receipt_document_type = 'Purchase Receipt',
receipt_document=pr.name, charges=100, do_not_save=True)
lcv1.insert()
lcv1.set('items', [
lcv1.get('items')[0]
])
distribute_landed_cost_on_items(lcv1)
lcv1.submit()
lcv2 = make_landed_cost_voucher(company = pr.company, receipt_document_type = 'Purchase Receipt',
receipt_document=pr.name, charges=100, do_not_save=True)
lcv2.insert()
lcv2.set('items', [
lcv2.get('items')[1]
])
distribute_landed_cost_on_items(lcv2)
lcv2.submit()
pr.load_from_db()
self.assertEqual(pr.items[0].landed_cost_voucher_amount, 100)
self.assertEqual(pr.items[1].landed_cost_voucher_amount, 100)
def test_asset_depreciation_value_adjustment(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
asset_doc.calculate_depreciation = 1
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
current_value = get_current_asset_value(asset_doc.name)
adj_doc = make_asset_value_adjustment(asset = asset_doc.name,
current_asset_value = current_value, new_asset_value = 50000.0)
adj_doc.submit()
expected_gle = (
("_Test Accumulated Depreciations - _TC", 0.0, 50000.0),
("_Test Depreciations - _TC", 50000.0, 0.0)
)
gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type='Journal Entry' and voucher_no = %s
order by account""", adj_doc.journal_entry)
self.assertEqual(gle, expected_gle)
def test_pro_rata_depreciation_entry_for_wdv(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=8000.0,
location="Test Location")
asset_name = frappe.db.get_value("Asset",
{"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2030-06-06'
asset.purchase_date = '2030-01-01'
asset.append(
"finance_books", {
"expected_value_after_useful_life": 1000,
"depreciation_method": "Written Down Value",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 12,
"depreciation_start_date": "2030-12-31"
})
asset.save(ignore_permissions=True)
self.assertEqual(asset.finance_books[0].rate_of_depreciation, 50.0)
expected_schedules = [
["2030-12-31", 2279.45, 2279.45],
["2031-12-31", 2860.28, 5139.73],
["2032-12-31", 1430.14, 6569.87],
["2033-06-06", 430.13, 7000.0],
]
schedules = [[
cstr(d.schedule_date),
flt(d.depreciation_amount, 2),
flt(d.accumulated_depreciation_amount, 2)
] for d in asset.get("schedules")]
self.assertEqual(schedules, expected_schedules)
def test_current_asset_value(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
current_value = get_current_asset_value(asset_doc.name)
self.assertEqual(current_value, 100000.0)
def test_asset_cwip_toggling_cases(self):
cwip = frappe.db.get_value("Asset Category", "Computers",
"enable_cwip_accounting")
name = frappe.db.get_value("Asset Category Account",
filters={"parent": "Computers"},
fieldname=["name"])
cwip_acc = "CWIP Account - _TC"
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", 0)
frappe.db.set_value("Asset Category Account", name,
"capital_work_in_progress_account", "")
frappe.db.get_value("Company", "_Test Company",
"capital_work_in_progress_account", "")
# case 0 -- PI with cwip disable, Asset with cwip disabled, No cwip account set
pi = make_purchase_invoice(item_code="Macbook Pro",
qty=1,
rate=200000.0,
location="Test Location",
update_stock=1)
asset = frappe.db.get_value('Asset', {
'purchase_invoice': pi.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
asset_doc.available_for_use_date = nowdate()
asset_doc.calculate_depreciation = 0
asset_doc.submit()
gle = frappe.db.sql(
"""select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""",
asset_doc.name)
self.assertFalse(gle)
# case 1 -- PR with cwip disabled, Asset with cwip enabled
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=200000.0,
location="Test Location")
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", 1)
frappe.db.set_value("Asset Category Account", name,
"capital_work_in_progress_account", cwip_acc)
asset = frappe.db.get_value('Asset', {
'purchase_receipt': pr.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
asset_doc.available_for_use_date = nowdate()
asset_doc.calculate_depreciation = 0
asset_doc.submit()
gle = frappe.db.sql(
"""select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""",
asset_doc.name)
self.assertFalse(gle)
# case 2 -- PR with cwip enabled, Asset with cwip disabled
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=200000.0,
location="Test Location")
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", 0)
asset = frappe.db.get_value('Asset', {
'purchase_receipt': pr.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
asset_doc.available_for_use_date = nowdate()
asset_doc.calculate_depreciation = 0
asset_doc.submit()
gle = frappe.db.sql(
"""select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""",
asset_doc.name)
self.assertTrue(gle)
# case 3 -- PI with cwip disabled, Asset with cwip enabled
pi = make_purchase_invoice(item_code="Macbook Pro",
qty=1,
rate=200000.0,
location="Test Location",
update_stock=1)
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", 1)
asset = frappe.db.get_value('Asset', {
'purchase_invoice': pi.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
asset_doc.available_for_use_date = nowdate()
asset_doc.calculate_depreciation = 0
asset_doc.submit()
gle = frappe.db.sql(
"""select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""",
asset_doc.name)
self.assertFalse(gle)
# case 4 -- PI with cwip enabled, Asset with cwip disabled
pi = make_purchase_invoice(item_code="Macbook Pro",
qty=1,
rate=200000.0,
location="Test Location",
update_stock=1)
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", 0)
asset = frappe.db.get_value('Asset', {
'purchase_invoice': pi.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
asset_doc.available_for_use_date = nowdate()
asset_doc.calculate_depreciation = 0
asset_doc.submit()
gle = frappe.db.sql(
"""select name from `tabGL Entry` where voucher_type='Asset' and voucher_no = %s""",
asset_doc.name)
self.assertTrue(gle)
frappe.db.set_value("Asset Category", "Computers",
"enable_cwip_accounting", cwip)
frappe.db.set_value("Asset Category Account", name,
"capital_work_in_progress_account", cwip_acc)
frappe.db.get_value("Company", "_Test Company",
"capital_work_in_progress_account", cwip_acc)
def test_reposting_of_sales_return_for_packed_item(self):
company = "_Test Company"
packed_item_code = "_Test Item for Reposting"
bundled_item = "_Test Bundled Item for Reposting"
create_product_bundle_item(bundled_item, [[packed_item_code, 4]])
# Purchase Return: Qty = 50, Rate = 100
pr = make_purchase_receipt(company=company,
posting_date='2020-04-10',
warehouse="Stores - _TC",
item_code=packed_item_code,
qty=50,
rate=100)
#Delivery Note: Qty = 5, Rate = 150
dn = create_delivery_note(item_code=bundled_item,
qty=5,
rate=150,
warehouse="Stores - _TC",
company=company,
expense_account="Cost of Goods Sold - _TC",
cost_center="Main - _TC")
# check outgoing_rate for DN
outgoing_rate = abs(
frappe.db.get_value("Stock Ledger Entry", {
"voucher_type": "Delivery Note",
"voucher_no": dn.name
}, "stock_value_difference") / 20)
self.assertEqual(dn.packed_items[0].incoming_rate, 100)
self.assertEqual(outgoing_rate, 100)
# Return Entry: Qty = -2, Rate = 150
return_dn = create_delivery_note(
is_return=1,
return_against=dn.name,
item_code=bundled_item,
qty=-2,
rate=150,
company=company,
warehouse="Stores - _TC",
expense_account="Cost of Goods Sold - _TC",
cost_center="Main - _TC")
# check incoming rate for Return entry
incoming_rate, stock_value_difference = frappe.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Delivery Note",
"voucher_no": return_dn.name
}, ["incoming_rate", "stock_value_difference"])
self.assertEqual(return_dn.packed_items[0].incoming_rate, 100)
self.assertEqual(incoming_rate, 100)
self.assertEqual(stock_value_difference, 800)
#-------------------------------
# Landed Cost Voucher to update the rate of incoming Purchase Return: Additional cost = 50
lcv = create_landed_cost_voucher("Purchase Receipt", pr.name,
pr.company)
# check outgoing_rate for DN after reposting
outgoing_rate = abs(
frappe.db.get_value("Stock Ledger Entry", {
"voucher_type": "Delivery Note",
"voucher_no": dn.name
}, "stock_value_difference") / 20)
self.assertEqual(outgoing_rate, 101)
dn.reload()
self.assertEqual(dn.packed_items[0].incoming_rate, 101)
# check incoming rate for Return entry after reposting
incoming_rate, stock_value_difference = frappe.db.get_value(
"Stock Ledger Entry", {
"voucher_type": "Delivery Note",
"voucher_no": return_dn.name
}, ["incoming_rate", "stock_value_difference"])
self.assertEqual(incoming_rate, 101)
self.assertEqual(stock_value_difference, 808)
return_dn.reload()
self.assertEqual(return_dn.packed_items[0].incoming_rate, 101)
# Cleanup data
return_dn.cancel()
dn.cancel()
lcv.cancel()
pr.cancel()
def test_cwip_accounting(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1,
rate=5000,
do_not_submit=True,
location="Test Location")
pr.set('taxes', [{
'category': 'Total',
'add_deduct_tax': 'Add',
'charge_type': 'On Net Total',
'account_head': '_Test Account Service Tax - _TC',
'description': '_Test Account Service Tax',
'cost_center': 'Main - _TC',
'rate': 5.0
}, {
'category': 'Valuation and Total',
'add_deduct_tax': 'Add',
'charge_type': 'On Net Total',
'account_head': '_Test Account Shipping Charges - _TC',
'description': '_Test Account Shipping Charges',
'cost_center': 'Main - _TC',
'rate': 5.0
}])
pr.submit()
expected_gle = (("Asset Received But Not Billed - _TC", 0.0, 5250.0),
("CWIP Account - _TC", 5250.0, 0.0))
pr_gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Purchase Receipt' and voucher_no = %s
order by account""", pr.name)
self.assertEqual(pr_gle, expected_gle)
pi = make_invoice(pr.name)
pi.submit()
expected_gle = (
("_Test Account Service Tax - _TC", 250.0, 0.0),
("_Test Account Shipping Charges - _TC", 250.0, 0.0),
("Asset Received But Not Billed - _TC", 5250.0, 0.0),
("Creditors - _TC", 0.0, 5500.0),
("Expenses Included In Asset Valuation - _TC", 0.0, 250.0),
)
pi_gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Purchase Invoice' and voucher_no = %s
order by account""", pi.name)
self.assertEqual(pi_gle, expected_gle)
asset = frappe.db.get_value('Asset', {
'purchase_receipt': pr.name,
'docstatus': 0
}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
month_end_date = get_last_day(nowdate())
asset_doc.available_for_use_date = nowdate(
) if nowdate() != month_end_date else add_days(nowdate(), -15)
self.assertEqual(asset_doc.gross_purchase_amount, 5250.0)
asset_doc.append(
"finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
expected_gle = (("_Test Fixed Asset - _TC", 5250.0, 0.0),
("CWIP Account - _TC", 0.0, 5250.0))
gle = frappe.db.sql(
"""select account, debit, credit from `tabGL Entry`
where voucher_type='Asset' and voucher_no = %s
order by account""", asset_doc.name)
self.assertEqual(gle, expected_gle)
