def test_max_continuous_leaves(self):
employee = get_employee()
leave_period = get_leave_period()
dataent.delete_doc_if_exists("Leave Type", "Test Leave Type", force=1)
leave_type = dataent.get_doc(dict(
leave_type_name = 'Test Leave Type',
doctype = 'Leave Type',
max_leaves_allowed = 15,
max_continuous_days_allowed = 3
)).insert()
date = add_days(nowdate(), -7)
allocate_leaves(employee, leave_period, leave_type.name, 10)
leave_application = dataent.get_doc(dict(
doctype = 'Leave Application',
employee = employee.name,
leave_type = leave_type.name,
from_date = date,
to_date = add_days(date, 4),
company = "_Test Company",
docstatus = 1,
status = "Approved"
))
self.assertRaises(dataent.ValidationError, leave_application.insert)
def get_todays_events(as_list=False): """Returns a count of todays events in calendar""" from dataent.desk.doctype.event.event import get_events from dataent.utils import nowdate today = nowdate() events = get_events(today, today) return events if as_list else len(events)
def test_earned_leave(self):
leave_period = get_leave_period()
employee = get_employee()
leave_type = 'Test Earned Leave Type'
if not dataent.db.exists('Leave Type', leave_type):
dataent.get_doc(dict(
leave_type_name = leave_type,
doctype = 'Leave Type',
is_earned_leave = 1,
earned_leave_frequency = 'Monthly',
rounding = 0.5,
max_leaves_allowed = 6
)).insert()
leave_policy = dataent.get_doc({
"doctype": "Leave Policy",
"leave_policy_details": [{"leave_type": leave_type, "annual_allocation": 6}]
}).insert()
dataent.db.set_value("Employee", employee.name, "leave_policy", leave_policy.name)
allocate_leaves(employee, leave_period, leave_type, 0, eligible_leaves = 12)
from epaas.hr.utils import allocate_earned_leaves
i = 0
while(i<14):
allocate_earned_leaves()
i += 1
self.assertEqual(get_leave_balance_on(employee.name, leave_type, nowdate()), 6)
def create_delivery_note(**args):
dn = dataent.new_doc("Delivery Note")
args = dataent._dict(args)
dn.posting_date = args.posting_date or nowdate()
dn.posting_time = args.posting_time or nowtime()
dn.set_posting_time = 1
dn.company = args.company or "_Test Company"
dn.customer = args.customer or "_Test Customer"
dn.currency = args.currency or "INR"
dn.is_return = args.is_return
dn.return_against = args.return_against
dn.append("items", {
"item_code": args.item or args.item_code or "_Test Item",
"warehouse": args.warehouse or "_Test Warehouse - _TC",
"qty": args.qty or 1,
"rate": args.rate or 100,
"conversion_factor": 1.0,
"expense_account": "Cost of Goods Sold - _TC",
"cost_center": args.cost_center or "_Test Cost Center - _TC",
"serial_no": args.serial_no,
"target_warehouse": args.target_warehouse
})
if not args.do_not_save:
dn.insert()
if not args.do_not_submit:
dn.submit()
return dn
def get_entries(filters):
conditions = get_conditions(filters)
journal_entries = dataent.db.sql("""SELECT
"Journal Entry", jv.name, jv.posting_date, jv.cheque_no,
jv.clearance_date, jvd.against_account, jvd.debit - jvd.credit
FROM
`tabJournal Entry Account` jvd, `tabJournal Entry` jv
WHERE
jvd.parent = jv.name and jv.docstatus=1 and jvd.account = %(account)s {0}
order by posting_date DESC, jv.name DESC""".format(conditions),
filters,
as_list=1)
payment_entries = dataent.db.sql("""SELECT
"Payment Entry", name, posting_date, reference_no, clearance_date, party,
if(paid_from=%(account)s, paid_amount * -1, received_amount)
FROM
`tabPayment Entry`
WHERE
docstatus=1 and (paid_from = %(account)s or paid_to = %(account)s) {0}
order by posting_date DESC, name DESC""".format(conditions),
filters,
as_list=1)
return sorted(journal_entries + payment_entries,
key=lambda k: k[2] or getdate(nowdate()))
def test_purchase_invoice_blocked_invoice_must_be_in_future(self): pi = make_purchase_invoice(do_not_save=True) pi.release_date = nowdate() self.assertRaises(dataent.ValidationError, pi.save) pi.release_date = '' pi.save()
def make_payment_entry(advance):
journal_entry = dataent.get_doc(make_bank_entry("Employee Advance", advance.name))
journal_entry.cheque_no = "123123"
journal_entry.cheque_date = nowdate()
journal_entry.save()
return journal_entry
def get_product_list(search=None, start=0, limit=12):
# limit = 12 because we show 12 items in the grid view
# base query
query = """select I.name, I.item_name, I.item_code, I.route, I.image, I.website_image, I.thumbnail, I.item_group,
I.description, I.web_long_description as website_description, I.is_stock_item,
case when (S.actual_qty - S.reserved_qty) > 0 then 1 else 0 end as in_stock, I.website_warehouse,
I.has_batch_no
from `tabItem` I
left join tabBin S on I.item_code = S.item_code and I.website_warehouse = S.warehouse
where (I.show_in_website = 1)
and I.disabled = 0
and (I.end_of_life is null or I.end_of_life='0000-00-00' or I.end_of_life > %(today)s)"""
# search term condition
if search:
query += """ and (I.web_long_description like %(search)s
or I.description like %(search)s
or I.item_name like %(search)s
or I.name like %(search)s)"""
search = "%" + cstr(search) + "%"
# order by
query += """ order by I.weightage desc, in_stock desc, I.modified desc limit %s, %s""" % (cint(start), cint(limit))
data = dataent.db.sql(query, {
"search": search,
"today": nowdate()
}, as_dict=1)
for item in data:
set_product_info_for_website(item)
return [get_item_for_list_in_html(r) for r in data]
def set_indicator(self): if self.docstatus==1: self.indicator_color = 'blue' self.indicator_title = 'Submitted' if self.valid_till and getdate(self.valid_till) < getdate(nowdate()): self.indicator_color = 'darkgrey' self.indicator_title = 'Expired'
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 make_raw_material_request(items, company, sales_order, project=None):
if not dataent.has_permission("Sales Order", "write"):
dataent.throw(_("Not permitted"), dataent.PermissionError)
if isinstance(items, string_types):
items = dataent._dict(json.loads(items))
for item in items.get('items'):
item["include_exploded_items"] = items.get('include_exploded_items')
item["ignore_existing_ordered_qty"] = items.get(
'ignore_existing_ordered_qty')
item["include_raw_materials_from_sales_order"] = items.get(
'include_raw_materials_from_sales_order')
raw_materials = get_items_for_material_requests(items, sales_order,
company)
if not raw_materials:
dataent.msgprint(
_("Material Request not created, as quantity for Raw Materials already available."
))
return
material_request = dataent.new_doc('Material Request')
material_request.update(
dict(doctype='Material Request',
transaction_date=nowdate(),
company=company,
requested_by=dataent.session.user,
material_request_type='Purchase'))
for item in raw_materials:
item_doc = dataent.get_cached_doc('Item', item.get('item_code'))
schedule_date = add_days(nowdate(), cint(item_doc.lead_time_days))
material_request.append(
'items', {
'item_code': item.get('item_code'),
'qty': item.get('quantity'),
'schedule_date': schedule_date,
'warehouse': item.get('warehouse'),
'sales_order': sales_order,
'project': project
})
material_request.insert()
material_request.flags.ignore_permissions = 1
material_request.run_method("set_missing_values")
material_request.submit()
return material_request
def get_expired_batches(batches):
"""
:param batches: A list of dict in the form [{'expiry_date': datetime.date(20XX, 1, 1), 'name': 'batch_id'}, ...]
"""
return [
b.name for b in batches
if b.expiry_date and b.expiry_date <= getdate(nowdate())
]
def send_reminder():
dataent.has_permission('GST Settings', throw=True)
last_sent = dataent.db.get_single_value('GST Settings',
'gstin_email_sent_on')
if last_sent and date_diff(nowdate(), last_sent) < 3:
dataent.throw(_("Please wait 3 days before resending the reminder."))
dataent.db.set_value('GST Settings', 'GST Settings', 'gstin_email_sent_on',
nowdate())
# enqueue if large number of customers, suppliser
dataent.enqueue(
'epaas.regional.doctype.gst_settings.gst_settings.send_gstin_reminder_to_all_parties'
)
dataent.msgprint(
_('Email Reminders will be sent to all parties with email contacts'))
def make_payament_entry_against_sales_invoice(doc, shopify_settings):
from epaas.accounts.doctype.payment_entry.payment_entry import get_payment_entry
payemnt_entry = get_payment_entry(
doc.doctype, doc.name, bank_account=shopify_settings.cash_bank_account)
payemnt_entry.flags.ignore_mandatory = True
payemnt_entry.reference_no = doc.name
payemnt_entry.reference_date = nowdate()
payemnt_entry.submit()
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 = dataent.db.get_value("Asset",
{"purchase_receipt": pr.name},
'name')
asset_doc = dataent.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 = dataent.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_make_sales_order_with_terms(self):
from epaas.selling.doctype.quotation.quotation import make_sales_order
quotation = dataent.copy_doc(test_records[0])
quotation.transaction_date = nowdate()
quotation.valid_till = add_months(quotation.transaction_date, 1)
quotation.update(
{"payment_terms_template": "_Test Payment Term Template"})
quotation.insert()
self.assertRaises(dataent.ValidationError, make_sales_order,
quotation.name)
quotation.save()
quotation.submit()
self.assertEqual(quotation.payment_schedule[0].payment_amount, 8906.00)
self.assertEqual(quotation.payment_schedule[0].due_date,
quotation.transaction_date)
self.assertEqual(quotation.payment_schedule[1].payment_amount, 8906.00)
self.assertEqual(quotation.payment_schedule[1].due_date,
add_days(quotation.transaction_date, 30))
sales_order = make_sales_order(quotation.name)
self.assertEqual(sales_order.doctype, "Sales Order")
self.assertEqual(len(sales_order.get("items")), 1)
self.assertEqual(
sales_order.get("items")[0].doctype, "Sales Order Item")
self.assertEqual(
sales_order.get("items")[0].prevdoc_docname, quotation.name)
self.assertEqual(sales_order.customer, "_Test Customer")
sales_order.delivery_date = "2014-01-01"
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = nowdate()
sales_order.insert()
self.assertEqual(sales_order.payment_schedule[0].payment_amount,
8906.00)
self.assertEqual(sales_order.payment_schedule[0].due_date,
getdate(quotation.transaction_date))
self.assertEqual(sales_order.payment_schedule[1].payment_amount,
8906.00)
self.assertEqual(sales_order.payment_schedule[1].due_date,
getdate(add_days(quotation.transaction_date, 30)))
def validate(self):
for task in self.get('asset_maintenance_tasks'):
if task.end_date and (getdate(task.start_date) >= getdate(
task.end_date)):
throw(
_("Start date should be less than end date for task {0}").
format(task.maintenance_task))
if getdate(task.next_due_date) < getdate(nowdate()):
task.maintenance_status = "Overdue"
def test_purchase_invoice_temporary_blocked(self):
pi = make_purchase_invoice(do_not_save=True)
pi.release_date = add_days(nowdate(), 10)
pi.save()
pi.submit()
pe = get_payment_entry('Purchase Invoice', dn=pi.name, bank_account="_Test Bank - _TC")
self.assertRaises(dataent.ValidationError, pe.save)
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_inter_company_jv(self):
dataent.db.set_value("Account", "Sales Expenses - _TC",
"inter_company_account", 1)
dataent.db.set_value("Account", "Buildings - _TC",
"inter_company_account", 1)
dataent.db.set_value("Account", "Sales Expenses - _TC1",
"inter_company_account", 1)
dataent.db.set_value("Account", "Buildings - _TC1",
"inter_company_account", 1)
jv = make_journal_entry("Sales Expenses - _TC",
"Buildings - _TC",
100,
posting_date=nowdate(),
cost_center="Main - _TC",
save=False)
jv.voucher_type = "Inter Company Journal Entry"
jv.multi_currency = 0
jv.insert()
jv.submit()
jv1 = make_journal_entry("Sales Expenses - _TC1",
"Buildings - _TC1",
100,
posting_date=nowdate(),
cost_center="Main - _TC1",
save=False)
jv1.inter_company_journal_entry_reference = jv.name
jv1.company = "_Test Company 1"
jv1.voucher_type = "Inter Company Journal Entry"
jv1.multi_currency = 0
jv1.insert()
jv1.submit()
jv.reload()
self.assertEqual(jv.inter_company_journal_entry_reference, jv1.name)
self.assertEqual(jv1.inter_company_journal_entry_reference, jv.name)
jv.cancel()
jv1.reload()
jv.reload()
self.assertEqual(jv.inter_company_journal_entry_reference, "")
self.assertEqual(jv1.inter_company_journal_entry_reference, "")
def validate_asset_finance_books(self, row):
if flt(row.expected_value_after_useful_life) >= flt(
self.gross_purchase_amount):
dataent.throw(
_("Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount"
).format(row.idx))
if not row.depreciation_start_date:
dataent.throw(
_("Row {0}: Depreciation Start Date is required").format(
row.idx))
if not self.is_existing_asset:
self.opening_accumulated_depreciation = 0
self.number_of_depreciations_booked = 0
else:
depreciable_amount = flt(self.gross_purchase_amount) - flt(
row.expected_value_after_useful_life)
if flt(self.opening_accumulated_depreciation) > depreciable_amount:
dataent.throw(
_("Opening Accumulated Depreciation must be less than equal to {0}"
).format(depreciable_amount))
if self.opening_accumulated_depreciation:
if not self.number_of_depreciations_booked:
dataent.throw(
_("Please set Number of Depreciations Booked"))
else:
self.number_of_depreciations_booked = 0
if cint(self.number_of_depreciations_booked) > cint(
row.total_number_of_depreciations):
dataent.throw(
_("Number of Depreciations Booked cannot be greater than Total Number of Depreciations"
))
if row.depreciation_start_date and getdate(
row.depreciation_start_date) < getdate(nowdate()):
dataent.msgprint(_(
"Depreciation Row {0}: Depreciation Start Date is entered as past date"
).format(row.idx),
title=_('Warning'),
indicator='red')
if row.depreciation_start_date and getdate(
row.depreciation_start_date) < getdate(self.purchase_date):
dataent.throw(
_("Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date"
).format(row.idx))
if row.depreciation_start_date and getdate(
row.depreciation_start_date) < getdate(
self.available_for_use_date):
dataent.throw(
_("Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date"
).format(row.idx))
def postprocess(source, target_doc):
target_doc.supplier = source_name
if getdate(target_doc.schedule_date) < getdate(nowdate()):
target_doc.schedule_date = None
target_doc.set("items", [
d for d in target_doc.get("items")
if d.get("item_code") in supplier_items and d.get("qty") > 0
])
set_missing_values(source, target_doc)
def create_sms_log(args, sent_to):
sl = dataent.new_doc('SMS Log')
sl.sent_on = nowdate()
sl.message = args['message'].decode('utf-8')
sl.no_of_requested_sms = len(args['receiver_list'])
sl.requested_numbers = "\n".join(args['receiver_list'])
sl.no_of_sent_sms = len(sent_to)
sl.sent_to = "\n".join(sent_to)
sl.flags.ignore_permissions = True
sl.save()
def test_staffing_plan(self):
_set_up()
dataent.db.set_value("Company", "_Test Company", "is_group", 1)
if dataent.db.exists("Staffing Plan", "Test"):
return
staffing_plan = dataent.new_doc("Staffing Plan")
staffing_plan.company = "_Test Company 10"
staffing_plan.name = "Test"
staffing_plan.from_date = nowdate()
staffing_plan.to_date = add_days(nowdate(), 10)
staffing_plan.append(
"staffing_details", {
"designation": "Designer",
"number_of_positions": 6,
"estimated_cost_per_position": 50000
})
staffing_plan.insert()
staffing_plan.submit()
self.assertEqual(staffing_plan.total_estimated_budget, 300000.00)
def test_expense_claim_status(self):
payable_account = get_payable_account("Wind Power LLC")
expense_claim = make_expense_claim(payable_account, 300, 200,
"Wind Power LLC",
"Travel Expenses - WP")
je_dict = make_bank_entry("Expense Claim", expense_claim.name)
je = dataent.get_doc(je_dict)
je.posting_date = nowdate()
je.cheque_no = random_string(5)
je.cheque_date = nowdate()
je.submit()
expense_claim = dataent.get_doc("Expense Claim", expense_claim.name)
self.assertEqual(expense_claim.status, "Paid")
je.cancel()
expense_claim = dataent.get_doc("Expense Claim", expense_claim.name)
self.assertEqual(expense_claim.status, "Unpaid")
def set_maintenance_status(self):
if not self.warranty_expiry_date and not self.amc_expiry_date:
self.maintenance_status = None
if self.warranty_expiry_date and getdate(
self.warranty_expiry_date) < getdate(nowdate()):
self.maintenance_status = "Out of Warranty"
if self.amc_expiry_date and getdate(self.amc_expiry_date) < getdate(
nowdate()):
self.maintenance_status = "Out of AMC"
if self.amc_expiry_date and getdate(self.amc_expiry_date) >= getdate(
nowdate()):
self.maintenance_status = "Under AMC"
if self.warranty_expiry_date and getdate(
self.warranty_expiry_date) >= getdate(nowdate()):
self.maintenance_status = "Under Warranty"
def test_make_sales_order_with_different_currency(self):
from epaas.selling.doctype.quotation.quotation import make_sales_order
quotation = dataent.copy_doc(test_records[0])
quotation.transaction_date = nowdate()
quotation.valid_till = add_months(quotation.transaction_date, 1)
quotation.insert()
quotation.submit()
sales_order = make_sales_order(quotation.name)
sales_order.currency = "USD"
sales_order.conversion_rate = 20.0
sales_order.delivery_date = "2019-01-01"
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = nowdate()
sales_order.insert()
self.assertEquals(sales_order.currency, "USD")
self.assertNotEqual(sales_order.currency, quotation.currency)
def make_gl_entries(self):
gl_entries = []
if ((self.purchase_receipt or
(self.purchase_invoice and dataent.db.get_value(
'Purchase Invoice', self.purchase_invoice, 'update_stock')))
and self.purchase_receipt_amount
and self.available_for_use_date <= nowdate()):
fixed_aseet_account = get_asset_category_account(
self.name,
'fixed_asset_account',
asset_category=self.asset_category,
company=self.company)
cwip_account = get_asset_account(
"capital_work_in_progress_account", self.name,
self.asset_category, self.company)
gl_entries.append(
self.get_gl_dict({
"account":
cwip_account,
"against":
fixed_aseet_account,
"remarks":
self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date":
self.available_for_use_date,
"credit":
self.purchase_receipt_amount,
"credit_in_account_currency":
self.purchase_receipt_amount
}))
gl_entries.append(
self.get_gl_dict({
"account":
fixed_aseet_account,
"against":
cwip_account,
"remarks":
self.get("remarks") or _("Accounting Entry for Asset"),
"posting_date":
self.available_for_use_date,
"debit":
self.purchase_receipt_amount,
"debit_in_account_currency":
self.purchase_receipt_amount
}))
if gl_entries:
from epaas.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
self.db_set('booked_fixed_asset', 1)
def create_payment_entry(self, submit=True):
"""create entry"""
dataent.flags.ignore_account_permission = True
ref_doc = dataent.get_doc(self.reference_doctype, self.reference_name)
if self.reference_doctype == "Sales Invoice":
party_account = ref_doc.debit_to
elif self.reference_doctype == "Purchase Invoice":
party_account = ref_doc.credit_to
else:
party_account = get_party_account("Customer",
ref_doc.get("customer"),
ref_doc.company)
party_account_currency = ref_doc.get(
"party_account_currency") or get_account_currency(party_account)
bank_amount = self.grand_total
if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
party_amount = ref_doc.base_grand_total
else:
party_amount = self.grand_total
payment_entry = get_payment_entry(self.reference_doctype,
self.reference_name,
party_amount=party_amount,
bank_account=self.payment_account,
bank_amount=bank_amount)
payment_entry.update({
"reference_no":
self.name,
"reference_date":
nowdate(),
"remarks":
"Payment Entry against {0} {1} via Payment Request {2}".format(
self.reference_doctype, self.reference_name, self.name)
})
if payment_entry.difference_amount:
company_details = get_company_defaults(ref_doc.company)
payment_entry.append(
"deductions", {
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount
})
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
return payment_entry
def test_movement_for_serialized_asset(self):
asset_item = "Test Serialized Asset Item"
pr = make_purchase_receipt(item_code=asset_item, rate = 1000, qty=3, location = "Mumbai")
asset_name = dataent.db.get_value('Asset', {'purchase_receipt': pr.name}, 'name')
asset = dataent.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
asset.available_for_use_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset.calculate_depreciation = 1
asset.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.submit()
serial_nos = dataent.db.get_value('Asset Movement', {'reference_name': pr.name}, 'serial_no')
mov1 = create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, source_location = "Mumbai", target_location="Pune", serial_no=serial_nos)
self.assertEqual(mov1.target_location, "Pune")
serial_no = dataent.db.get_value('Serial No', {'asset': asset_name}, 'name')
employee = make_employee("*****@*****.**")
create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, serial_no=serial_no, to_employee=employee)
self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'employee'), employee)
create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company,
serial_no=serial_no, from_employee=employee, to_employee="_T-Employee-00001")
self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'location'), "Pune")
mov4 = create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, source_location = "Pune", target_location="Nagpur", serial_no=serial_nos)
self.assertEqual(mov4.target_location, "Nagpur")
self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'location'), "Nagpur")
self.assertEqual(dataent.db.get_value('Serial No', serial_no, 'employee'), "_T-Employee-00001")
