def set_account_heads():
from erpnext.accounts.doctype.account.test_account import create_account
create_account(account_name="Cess",
parent_account="Duties and Taxes - _GST",
company="_Test Company GST")
gst_settings = frappe.get_doc("GST Settings")
gst_account = frappe.get_all(
"GST Account",
fields=["cgst_account", "sgst_account", "igst_account"],
filters={"company": "_Test Company GST"})
if not gst_account:
gst_settings.append(
"gst_accounts", {
"company": "_Test Company GST",
"cgst_account": "CGST - _GST",
"sgst_account": "SGST - _GST",
"igst_account": "IGST - _GST",
"cess_account": "Cess - _GST"
})
gst_settings.save()
def setUp(self):
frappe.set_user("Administrator")
make_company("_Test Company SA VAT", "_TCSV")
create_account(
account_name="VAT - 0%",
account_type="Tax",
parent_account="Duties and Taxes - _TCSV",
company="_Test Company SA VAT",
)
create_account(
account_name="VAT - 15%",
account_type="Tax",
parent_account="Duties and Taxes - _TCSV",
company="_Test Company SA VAT",
)
set_sa_vat_accounts()
make_item("_Test SA VAT Item")
make_item("_Test SA VAT Zero Rated Item",
properties={"is_zero_rated": 1})
make_customer()
make_supplier()
make_sales_invoices()
create_purchase_invoices()
def test_deferred_expense_via_journal_entry(self):
deferred_account = create_account(account_name="Deferred Expense",
parent_account="Current Assets - _TC", company="_Test Company")
acc_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
acc_settings.book_deferred_entries_via_journal_entry = 1
acc_settings.submit_journal_entries = 1
acc_settings.save()
item = create_item("_Test Item for Deferred Accounting", is_purchase_item=True)
item.enable_deferred_expense = 1
item.deferred_expense_account = deferred_account
item.save()
pi = make_purchase_invoice(item=item.name, qty=1, rate=100, do_not_save=True)
pi.set_posting_time = 1
pi.posting_date = '2019-03-15'
pi.items[0].enable_deferred_expense = 1
pi.items[0].service_start_date = "2019-01-10"
pi.items[0].service_end_date = "2019-03-15"
pi.items[0].deferred_expense_account = deferred_account
pi.save()
pi.submit()
pda1 = frappe.get_doc(dict(
doctype='Process Deferred Accounting',
posting_date=nowdate(),
start_date="2019-01-01",
end_date="2019-03-31",
type="Expense",
company="_Test Company"
))
pda1.insert()
pda1.submit()
expected_gle = [
["_Test Account Cost for Goods Sold - _TC", 0.0, 33.85, "2019-01-31"],
[deferred_account, 33.85, 0.0, "2019-01-31"],
["_Test Account Cost for Goods Sold - _TC", 0.0, 43.08, "2019-02-28"],
[deferred_account, 43.08, 0.0, "2019-02-28"],
["_Test Account Cost for Goods Sold - _TC", 0.0, 23.07, "2019-03-15"],
[deferred_account, 23.07, 0.0, "2019-03-15"]
]
gl_entries = gl_entries = frappe.db.sql("""select account, debit, credit, posting_date
from `tabGL Entry`
where voucher_type='Journal Entry' and voucher_detail_no=%s and posting_date <= %s
order by posting_date asc, account asc""", (pi.items[0].name, pi.posting_date), as_dict=1)
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_gle[i][0], gle.account)
self.assertEqual(expected_gle[i][1], gle.credit)
self.assertEqual(expected_gle[i][2], gle.debit)
self.assertEqual(getdate(expected_gle[i][3]), gle.posting_date)
acc_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
acc_settings.book_deferred_entries_via_journal_entry = 0
acc_settings.submit_journal_entriessubmit_journal_entries = 0
acc_settings.save()
def tearDown(self):
target_warehouse = "_Test Warehouse 1 - _TC"
company = "_Test Company"
if not frappe.db.exists("Account", target_warehouse):
parent_account = frappe.db.get_value('Account',
{'company': company, 'is_group':1, 'account_type': 'Stock'},'name')
account = create_account(account_name="_Test Warehouse 1", \
account_type="Stock", parent_account= parent_account, company=company)
frappe.db.set_value('Warehouse', target_warehouse, 'account', account)
def tearDown(self):
target_warehouse = "_Test Warehouse 1 - _TC"
company = "_Test Company"
if not frappe.db.exists("Account", target_warehouse):
parent_account = frappe.db.get_value('Account',
{'company': company, 'is_group':1, 'account_type': 'Stock'},'name')
account = create_account(account_name="_Test Warehouse 1", \
account_type="Stock", parent_account= parent_account, company=company)
frappe.db.set_value('Warehouse', target_warehouse, 'account', account)
def test_multi_currency_lcv(self):
## Create USD Shipping charges_account
usd_shipping = create_account(
account_name="Shipping Charges USD",
parent_account="Duties and Taxes - TCP1",
company="_Test Company with perpetual inventory",
account_currency="USD")
pr = make_purchase_receipt(
company="_Test Company with perpetual inventory",
warehouse="Stores - TCP1",
supplier_warehouse="Stores - TCP1")
pr.submit()
lcv = make_landed_cost_voucher(
company=pr.company,
receipt_document_type="Purchase Receipt",
receipt_document=pr.name,
charges=100,
do_not_save=True)
lcv.append(
"taxes", {
"description": "Shipping Charges",
"expense_account": usd_shipping,
"amount": 10
})
lcv.save()
lcv.submit()
pr.load_from_db()
# Considering exchange rate from USD to INR as 62.9
self.assertEqual(lcv.total_taxes_and_charges, 729)
self.assertEqual(pr.items[0].landed_cost_voucher_amount, 729)
gl_entries = frappe.get_all(
"GL Entry",
fields=["account", "credit", "credit_in_account_currency"],
filters={
"voucher_no":
pr.name,
"account": ("in", [
"Shipping Charges USD - TCP1",
"Expenses Included In Valuation - TCP1"
])
})
expected_gl_entries = {
"Shipping Charges USD - TCP1": [629, 10],
"Expenses Included In Valuation - TCP1": [100, 100]
}
for entry in gl_entries:
amounts = expected_gl_entries.get(entry.account)
self.assertEqual(entry.credit, amounts[0])
self.assertEqual(entry.credit_in_account_currency, amounts[1])
def make_account_for_warehouse(warehouse_name, warehouse_obj):
if not frappe.db.exists("Account", warehouse_name + " - _TC"):
parent_account = frappe.db.get_value(
'Account', {
'company': warehouse_obj.company,
'is_group': 1,
'account_type': 'Stock'
}, 'name')
account = create_account(account_name=warehouse_name, \
account_type="Stock", parent_account= parent_account, company=warehouse_obj.company)
def get_warehouse_account(warehouse_name, company, company_abbr=None):
if not company_abbr:
company_abbr = frappe.get_cached_value("Company", company, 'abbr')
if not frappe.db.exists("Account", warehouse_name + " - " + company_abbr):
return create_account(account_name=warehouse_name,
parent_account=get_group_stock_account(
company, company_abbr),
account_type='Stock',
company=company)
else:
return warehouse_name + " - " + company_abbr
def generate_taxes():
parent_account = frappe.db.get_value('Account',
{'company': company_name, 'is_group':1, 'account_type': 'Tax'},
'name')
account = create_account(company=company_name, account_name="CGST", account_type="Tax", parent_account=parent_account)
return {'taxes':[{
"account_head": account,
"rate": 0,
"description": "CGST",
"tax_amount": 10,
"total": 210
}]}
def setUp(self):
self.ar_credit = create_account(
account_name="_Test Accounts Receivable Credit",
parent_account="Accounts Receivable - _TC",
company="_Test Company")
self.ar_discounted = create_account(
account_name="_Test Accounts Receivable Discounted",
parent_account="Accounts Receivable - _TC",
company="_Test Company")
self.ar_unpaid = create_account(
account_name="_Test Accounts Receivable Unpaid",
parent_account="Accounts Receivable - _TC",
company="_Test Company")
self.short_term_loan = create_account(
account_name="_Test Short Term Loan",
parent_account="Source of Funds (Liabilities) - _TC",
company="_Test Company")
self.bank_account = create_account(
account_name="_Test Bank 2",
parent_account="Bank Accounts - _TC",
company="_Test Company")
self.bank_charges_account = create_account(
account_name="_Test Bank Charges Account",
parent_account="Expenses - _TC",
company="_Test Company")
frappe.db.set_value("Company", "_Test Company", "default_bank_account",
self.bank_account)
def test_creation_of_ledger_entry_on_submit(self):
"""test creation of gl entries on submission of document"""
deferred_account = create_account(
account_name="Deferred Revenue",
parent_account="Current Liabilities - _TC",
company="_Test Company",
)
item = create_item("_Test Item for Deferred Accounting")
item.enable_deferred_revenue = 1
item.deferred_revenue_account = deferred_account
item.no_of_months = 12
item.save()
si = create_sales_invoice(
item=item.name, update_stock=0, posting_date="2019-01-10", do_not_submit=True
)
si.items[0].enable_deferred_revenue = 1
si.items[0].service_start_date = "2019-01-10"
si.items[0].service_end_date = "2019-03-15"
si.items[0].deferred_revenue_account = deferred_account
si.save()
si.submit()
process_deferred_accounting = doc = frappe.get_doc(
dict(
doctype="Process Deferred Accounting",
posting_date="2019-01-01",
start_date="2019-01-01",
end_date="2019-01-31",
type="Income",
)
)
process_deferred_accounting.insert()
process_deferred_accounting.submit()
expected_gle = [
[deferred_account, 33.85, 0.0, "2019-01-31"],
["Sales - _TC", 0.0, 33.85, "2019-01-31"],
]
check_gl_entries(self, si.name, expected_gle, "2019-01-10")
def generate_taxes():
parent_account = frappe.db.get_value("Account", {
"company": company_name,
"is_group": 1,
"account_type": "Tax"
}, "name")
account = create_account(
company=company_name,
account_name="Output Tax CGST",
account_type="Tax",
parent_account=parent_account,
)
return {
"taxes": [{
"account_head": account,
"rate": 9,
"description": "CGST",
"tax_amount": 10,
"total": 210
}]
}
def execute():
# Create a penalty account for loan types
frappe.reload_doc('loan_management', 'doctype', 'loan_type')
frappe.reload_doc('loan_management', 'doctype', 'loan')
frappe.reload_doc('loan_management', 'doctype', 'repayment_schedule')
frappe.reload_doc('loan_management', 'doctype', 'process_loan_interest_accrual')
frappe.reload_doc('loan_management', 'doctype', 'loan_repayment')
frappe.reload_doc('loan_management', 'doctype', 'loan_repayment_detail')
frappe.reload_doc('loan_management', 'doctype', 'loan_interest_accrual')
frappe.reload_doc('accounts', 'doctype', 'gl_entry')
frappe.reload_doc('accounts', 'doctype', 'journal_entry_account')
updated_loan_types = []
loans_to_close = []
# Update old loan status as closed
if frappe.db.has_column('Repayment Schedule', 'paid'):
loans_list = frappe.db.sql("""SELECT distinct parent from `tabRepayment Schedule`
where paid = 0 and docstatus = 1""", as_dict=1)
loans_to_close = [d.parent for d in loans_list]
if loans_to_close:
frappe.db.sql("UPDATE `tabLoan` set status = 'Closed' where name not in (%s)" % (', '.join(['%s'] * len(loans_to_close))), tuple(loans_to_close))
loans = frappe.get_all('Loan', fields=['name', 'loan_type', 'company', 'status', 'mode_of_payment',
'applicant_type', 'applicant', 'loan_account', 'payment_account', 'interest_income_account'],
filters={'docstatus': 1, 'status': ('!=', 'Closed')})
for loan in loans:
# Update details in Loan Types and Loan
loan_type_company = frappe.db.get_value('Loan Type', loan.loan_type, 'company')
loan_type = loan.loan_type
group_income_account = frappe.get_value('Account', {'company': loan.company,
'is_group': 1, 'root_type': 'Income', 'account_name': _('Indirect Income')})
if not group_income_account:
group_income_account = frappe.get_value('Account', {'company': loan.company,
'is_group': 1, 'root_type': 'Income'})
penalty_account = create_account(company=loan.company, account_type='Income Account',
account_name='Penalty Account', parent_account=group_income_account)
# Same loan type used for multiple companies
if loan_type_company and loan_type_company != loan.company:
# get loan type for appropriate company
loan_type_name = frappe.get_value('Loan Type', {'company': loan.company,
'mode_of_payment': loan.mode_of_payment, 'loan_account': loan.loan_account,
'payment_account': loan.payment_account, 'interest_income_account': loan.interest_income_account,
'penalty_income_account': loan.penalty_income_account}, 'name')
if not loan_type_name:
loan_type_name = create_loan_type(loan, loan_type_name, penalty_account)
# update loan type in loan
frappe.db.sql("UPDATE `tabLoan` set loan_type = %s where name = %s", (loan_type_name,
loan.name))
loan_type = loan_type_name
if loan_type_name not in updated_loan_types:
updated_loan_types.append(loan_type_name)
elif not loan_type_company:
loan_type_doc = frappe.get_doc('Loan Type', loan.loan_type)
loan_type_doc.is_term_loan = 1
loan_type_doc.company = loan.company
loan_type_doc.mode_of_payment = loan.mode_of_payment
loan_type_doc.payment_account = loan.payment_account
loan_type_doc.loan_account = loan.loan_account
loan_type_doc.interest_income_account = loan.interest_income_account
loan_type_doc.penalty_income_account = penalty_account
loan_type_doc.submit()
updated_loan_types.append(loan.loan_type)
loan_type = loan.loan_type
if loan_type in updated_loan_types:
if loan.status == 'Fully Disbursed':
status = 'Disbursed'
elif loan.status == 'Repaid/Closed':
status = 'Closed'
else:
status = loan.status
frappe.db.set_value('Loan', loan.name, {
'is_term_loan': 1,
'penalty_income_account': penalty_account,
'status': status
})
process_loan_interest_accrual_for_term_loans(posting_date=nowdate(), loan_type=loan_type,
loan=loan.name)
if frappe.db.has_column('Repayment Schedule', 'paid'):
total_principal, total_interest = frappe.db.get_value('Repayment Schedule', {'paid': 1, 'parent': loan.name},
['sum(principal_amount) as total_principal', 'sum(interest_amount) as total_interest'])
accrued_entries = get_accrued_interest_entries(loan.name)
for entry in accrued_entries:
interest_paid = 0
principal_paid = 0
if flt(total_interest) > flt(entry.interest_amount):
interest_paid = flt(entry.interest_amount)
else:
interest_paid = flt(total_interest)
if flt(total_principal) > flt(entry.payable_principal_amount):
principal_paid = flt(entry.payable_principal_amount)
else:
principal_paid = flt(total_principal)
frappe.db.sql(""" UPDATE `tabLoan Interest Accrual`
SET paid_principal_amount = `paid_principal_amount` + %s,
paid_interest_amount = `paid_interest_amount` + %s
WHERE name = %s""",
(principal_paid, interest_paid, entry.name))
total_principal = flt(total_principal) - principal_paid
total_interest = flt(total_interest) - interest_paid
def execute():
# Create a penalty account for loan types
frappe.reload_doc("loan_management", "doctype", "loan_type")
frappe.reload_doc("loan_management", "doctype", "loan")
frappe.reload_doc("loan_management", "doctype", "repayment_schedule")
frappe.reload_doc("loan_management", "doctype", "process_loan_interest_accrual")
frappe.reload_doc("loan_management", "doctype", "loan_repayment")
frappe.reload_doc("loan_management", "doctype", "loan_repayment_detail")
frappe.reload_doc("loan_management", "doctype", "loan_interest_accrual")
frappe.reload_doc("accounts", "doctype", "gl_entry")
frappe.reload_doc("accounts", "doctype", "journal_entry_account")
updated_loan_types = []
loans_to_close = []
# Update old loan status as closed
if frappe.db.has_column("Repayment Schedule", "paid"):
loans_list = frappe.db.sql(
"""SELECT distinct parent from `tabRepayment Schedule`
where paid = 0 and docstatus = 1""",
as_dict=1,
)
loans_to_close = [d.parent for d in loans_list]
if loans_to_close:
frappe.db.sql(
"UPDATE `tabLoan` set status = 'Closed' where name not in (%s)"
% (", ".join(["%s"] * len(loans_to_close))),
tuple(loans_to_close),
)
loans = frappe.get_all(
"Loan",
fields=[
"name",
"loan_type",
"company",
"status",
"mode_of_payment",
"applicant_type",
"applicant",
"loan_account",
"payment_account",
"interest_income_account",
],
filters={"docstatus": 1, "status": ("!=", "Closed")},
)
for loan in loans:
# Update details in Loan Types and Loan
loan_type_company = frappe.db.get_value("Loan Type", loan.loan_type, "company")
loan_type = loan.loan_type
group_income_account = frappe.get_value(
"Account",
{
"company": loan.company,
"is_group": 1,
"root_type": "Income",
"account_name": _("Indirect Income"),
},
)
if not group_income_account:
group_income_account = frappe.get_value(
"Account", {"company": loan.company, "is_group": 1, "root_type": "Income"}
)
penalty_account = create_account(
company=loan.company,
account_type="Income Account",
account_name="Penalty Account",
parent_account=group_income_account,
)
# Same loan type used for multiple companies
if loan_type_company and loan_type_company != loan.company:
# get loan type for appropriate company
loan_type_name = frappe.get_value(
"Loan Type",
{
"company": loan.company,
"mode_of_payment": loan.mode_of_payment,
"loan_account": loan.loan_account,
"payment_account": loan.payment_account,
"interest_income_account": loan.interest_income_account,
"penalty_income_account": loan.penalty_income_account,
},
"name",
)
if not loan_type_name:
loan_type_name = create_loan_type(loan, loan_type_name, penalty_account)
# update loan type in loan
frappe.db.sql(
"UPDATE `tabLoan` set loan_type = %s where name = %s", (loan_type_name, loan.name)
)
loan_type = loan_type_name
if loan_type_name not in updated_loan_types:
updated_loan_types.append(loan_type_name)
elif not loan_type_company:
loan_type_doc = frappe.get_doc("Loan Type", loan.loan_type)
loan_type_doc.is_term_loan = 1
loan_type_doc.company = loan.company
loan_type_doc.mode_of_payment = loan.mode_of_payment
loan_type_doc.payment_account = loan.payment_account
loan_type_doc.loan_account = loan.loan_account
loan_type_doc.interest_income_account = loan.interest_income_account
loan_type_doc.penalty_income_account = penalty_account
loan_type_doc.submit()
updated_loan_types.append(loan.loan_type)
loan_type = loan.loan_type
if loan_type in updated_loan_types:
if loan.status == "Fully Disbursed":
status = "Disbursed"
elif loan.status == "Repaid/Closed":
status = "Closed"
else:
status = loan.status
frappe.db.set_value(
"Loan",
loan.name,
{"is_term_loan": 1, "penalty_income_account": penalty_account, "status": status},
)
process_loan_interest_accrual_for_term_loans(
posting_date=nowdate(), loan_type=loan_type, loan=loan.name
)
if frappe.db.has_column("Repayment Schedule", "paid"):
total_principal, total_interest = frappe.db.get_value(
"Repayment Schedule",
{"paid": 1, "parent": loan.name},
["sum(principal_amount) as total_principal", "sum(interest_amount) as total_interest"],
)
accrued_entries = get_accrued_interest_entries(loan.name)
for entry in accrued_entries:
interest_paid = 0
principal_paid = 0
if flt(total_interest) > flt(entry.interest_amount):
interest_paid = flt(entry.interest_amount)
else:
interest_paid = flt(total_interest)
if flt(total_principal) > flt(entry.payable_principal_amount):
principal_paid = flt(entry.payable_principal_amount)
else:
principal_paid = flt(total_principal)
frappe.db.sql(
""" UPDATE `tabLoan Interest Accrual`
SET paid_principal_amount = `paid_principal_amount` + %s,
paid_interest_amount = `paid_interest_amount` + %s
WHERE name = %s""",
(principal_paid, interest_paid, entry.name),
)
total_principal = flt(total_principal) - principal_paid
total_interest = flt(total_interest) - interest_paid
def execute():
# Create a penalty account for loan types
frappe.reload_doc('loan_management', 'doctype', 'loan_type')
frappe.reload_doc('loan_management', 'doctype', 'loan')
frappe.reload_doc('loan_management', 'doctype', 'repayment_schedule')
frappe.reload_doc('loan_management', 'doctype',
'process_loan_interest_accrual')
frappe.reload_doc('loan_management', 'doctype', 'loan_repayment')
frappe.reload_doc('loan_management', 'doctype', 'loan_repayment_detail')
frappe.reload_doc('loan_management', 'doctype', 'loan_interest_accrual')
frappe.reload_doc('accounts', 'doctype', 'gl_entry')
updated_loan_types = []
loans = frappe.get_all('Loan',
fields=[
'name', 'loan_type', 'company', 'status',
'mode_of_payment', 'applicant_type',
'applicant', 'loan_account', 'payment_account',
'interest_income_account'
])
for loan in loans:
# Update details in Loan Types and Loan
loan_type_company = frappe.db.get_value('Loan Type', loan.loan_type,
'company')
group_income_account = frappe.get_value(
'Account', {
'company': loan.company,
'is_group': 1,
'root_type': 'Income',
'account_name': _('Indirect Income')
})
if not group_income_account:
group_income_account = frappe.get_value('Account', {
'company': loan.company,
'is_group': 1,
'root_type': 'Income'
})
penalty_account = create_account(company=loan.company,
account_type='Income Account',
account_name='Penalty Account',
parent_account=group_income_account)
if not loan_type_company:
loan_type_doc = frappe.get_doc('Loan Type', loan.loan_type)
loan_type_doc.is_term_loan = 1
loan_type_doc.company = loan.company
loan_type_doc.mode_of_payment = loan.mode_of_payment
loan_type_doc.payment_account = loan.payment_account
loan_type_doc.loan_account = loan.loan_account
loan_type_doc.interest_income_account = loan.interest_income_account
loan_type_doc.penalty_income_account = penalty_account
loan_type_doc.submit()
updated_loan_types.append(loan.loan_type)
if loan.loan_type in updated_loan_types:
if loan.status == 'Fully Disbursed':
status = 'Disbursed'
elif loan.status == 'Repaid/Closed':
status = 'Closed'
else:
status = loan.status
frappe.db.set_value(
'Loan', loan.name, {
'is_term_loan': 1,
'penalty_income_account': penalty_account,
'status': status
})
process_loan_interest_accrual_for_term_loans(
posting_date=nowdate(),
loan_type=loan.loan_type,
loan=loan.name)
payments = frappe.db.sql(
''' SELECT j.name, a.debit, a.debit_in_account_currency, j.posting_date
FROM `tabJournal Entry` j, `tabJournal Entry Account` a
WHERE a.parent = j.name and a.reference_type='Loan' and a.reference_name = %s
and account = %s
''', (loan.name, loan.loan_account),
as_dict=1)
for payment in payments:
repayment_entry = make_repayment_entry(
loan.name, loan.loan_applicant_type, loan.applicant,
loan.loan_type, loan.company)
repayment_entry.amount_paid = payment.debit_in_account_currency
repayment_entry.posting_date = payment.posting_date
repayment_entry.save()
repayment_entry.submit()
jv = frappe.get_doc('Journal Entry', payment.name)
jv.flags.ignore_links = True
jv.cancel()
def make_account_for_warehouse(warehouse_name, warehouse_obj):
if not frappe.db.exists("Account", warehouse_name + " - _TC"):
parent_account = frappe.db.get_value('Account',
{'company': warehouse_obj.company, 'is_group':1, 'account_type': 'Stock'},'name')
account = create_account(account_name=warehouse_name, \
account_type="Stock", parent_account= parent_account, company=warehouse_obj.company)
def test_deferred_revenue(self):
self.clear_old_entries()
# created deferred expense accounts, if not found
deferred_revenue_account = create_account(
account_name="Deferred Revenue",
parent_account="Current Liabilities - _CD",
company="_Test Company DR",
)
acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
acc_settings.book_deferred_entries_based_on = "Months"
acc_settings.save()
customer = frappe.new_doc("Customer")
customer.customer_name = "_Test Customer DR"
customer.type = "Individual"
customer.insert()
item = create_item(
"_Test Internet Subscription",
is_stock_item=0,
warehouse="All Warehouses - _CD",
company="_Test Company DR",
)
item.enable_deferred_revenue = 1
item.deferred_revenue_account = deferred_revenue_account
item.no_of_months = 3
item.save()
si = create_sales_invoice(
item=item.name,
company="_Test Company DR",
customer="_Test Customer DR",
debit_to="Debtors - _CD",
posting_date="2021-05-01",
parent_cost_center="Main - _CD",
cost_center="Main - _CD",
do_not_save=True,
rate=300,
price_list_rate=300,
)
si.items[0].income_account = "Sales - _CD"
si.items[0].enable_deferred_revenue = 1
si.items[0].service_start_date = "2021-05-01"
si.items[0].service_end_date = "2021-08-01"
si.items[0].deferred_revenue_account = deferred_revenue_account
si.items[0].income_account = "Sales - _CD"
si.save()
si.submit()
pda = frappe.get_doc(
dict(
doctype="Process Deferred Accounting",
posting_date=nowdate(),
start_date="2021-05-01",
end_date="2021-08-01",
type="Income",
company="_Test Company DR",
))
pda.insert()
pda.submit()
# execute report
fiscal_year = frappe.get_doc(
"Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
self.filters = frappe._dict({
"company":
frappe.defaults.get_user_default("Company"),
"filter_based_on":
"Date Range",
"period_start_date":
"2021-05-01",
"period_end_date":
"2021-08-01",
"from_fiscal_year":
fiscal_year.year,
"to_fiscal_year":
fiscal_year.year,
"periodicity":
"Monthly",
"type":
"Revenue",
"with_upcoming_postings":
False,
})
report = Deferred_Revenue_and_Expense_Report(filters=self.filters)
report.run()
expected = [
{
"key": "may_2021",
"total": 100.0,
"actual": 100.0
},
{
"key": "jun_2021",
"total": 100.0,
"actual": 100.0
},
{
"key": "jul_2021",
"total": 100.0,
"actual": 100.0
},
{
"key": "aug_2021",
"total": 0,
"actual": 0
},
]
self.assertEqual(report.period_total, expected)
def test_deferred_expense(self):
self.clear_old_entries()
# created deferred expense accounts, if not found
deferred_expense_account = create_account(
account_name="Deferred Expense",
parent_account="Current Assets - _CD",
company="_Test Company DR",
)
acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
acc_settings.book_deferred_entries_based_on = "Months"
acc_settings.save()
supplier = create_supplier(supplier_name="_Test Furniture Supplier",
supplier_group="Local",
supplier_type="Company")
supplier.save()
item = create_item(
"_Test Office Desk",
is_stock_item=0,
warehouse="All Warehouses - _CD",
company="_Test Company DR",
)
item.enable_deferred_expense = 1
item.deferred_expense_account = deferred_expense_account
item.no_of_months_exp = 3
item.save()
pi = make_purchase_invoice(
item=item.name,
company="_Test Company DR",
supplier="_Test Furniture Supplier",
is_return=False,
update_stock=False,
posting_date=frappe.utils.datetime.date(2021, 5, 1),
parent_cost_center="Main - _CD",
cost_center="Main - _CD",
do_not_save=True,
rate=300,
price_list_rate=300,
warehouse="All Warehouses - _CD",
qty=1,
)
pi.set_posting_time = True
pi.items[0].enable_deferred_expense = 1
pi.items[0].service_start_date = "2021-05-01"
pi.items[0].service_end_date = "2021-08-01"
pi.items[0].deferred_expense_account = deferred_expense_account
pi.items[0].expense_account = "Office Maintenance Expenses - _CD"
pi.save()
pi.submit()
pda = frappe.get_doc(
dict(
doctype="Process Deferred Accounting",
posting_date=nowdate(),
start_date="2021-05-01",
end_date="2021-08-01",
type="Expense",
company="_Test Company DR",
))
pda.insert()
pda.submit()
# execute report
fiscal_year = frappe.get_doc(
"Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
self.filters = frappe._dict({
"company":
frappe.defaults.get_user_default("Company"),
"filter_based_on":
"Date Range",
"period_start_date":
"2021-05-01",
"period_end_date":
"2021-08-01",
"from_fiscal_year":
fiscal_year.year,
"to_fiscal_year":
fiscal_year.year,
"periodicity":
"Monthly",
"type":
"Expense",
"with_upcoming_postings":
False,
})
report = Deferred_Revenue_and_Expense_Report(filters=self.filters)
report.run()
expected = [
{
"key": "may_2021",
"total": -100.0,
"actual": -100.0
},
{
"key": "jun_2021",
"total": -100.0,
"actual": -100.0
},
{
"key": "jul_2021",
"total": -100.0,
"actual": -100.0
},
{
"key": "aug_2021",
"total": 0,
"actual": 0
},
]
self.assertEqual(report.period_total, expected)
