forked from Mapan/odoo17e
509 lines
24 KiB
Python
509 lines
24 KiB
Python
# -*- coding:utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from collections import defaultdict
|
|
from datetime import date
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from odoo import Command
|
|
from odoo.tests import tagged
|
|
|
|
from .common import TestPayrollCommon
|
|
|
|
|
|
@tagged("post_install_l10n", "post_install", "-at_install", "l10n_au_hr_payroll")
|
|
class TestPayroll(TestPayrollCommon):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super(TestPayroll, cls).setUpClass()
|
|
cls.struct_regular = cls.env.ref("l10n_au_hr_payroll.hr_payroll_structure_au_regular")
|
|
|
|
def test_withholding_amounts(self):
|
|
test_scales = ["1", "2", "3", "5", "6"]
|
|
today = date.today()
|
|
payslip = self.env["hr.payslip"].create({
|
|
"name": "Test Payslip AU",
|
|
"employee_id": self.employee_id.id,
|
|
"date_from": today,
|
|
"date_to": today,
|
|
"struct_id": self.struct_regular.id,
|
|
})
|
|
payslip._compute_date_to()
|
|
|
|
coefficients = payslip._rule_parameter("l10n_au_withholding_coefficients")["regular"]
|
|
for period, sample_data in self.schedule_1_withholding_sample_data.items():
|
|
for row in sample_data:
|
|
earnings = row[0]
|
|
self.contract_ids[0].wage = earnings
|
|
for idx, test_data in enumerate(row[1:]):
|
|
self.employee_id.l10n_au_scale = test_scales[idx]
|
|
amount = payslip._l10n_au_compute_withholding_amount(earnings, period, coefficients)
|
|
self.assertEqual(amount, test_data, f"weekly earnings of {earnings} scale {self.employee_id.l10n_au_scale}: expected {test_data} got {-amount}")
|
|
|
|
def test_medicare_adjustment(self):
|
|
nbr_children = [0, 1, 2, 3, 4, 5]
|
|
today = date.today()
|
|
self.employee_id.marital = "married"
|
|
payslip = self.env["hr.payslip"].create({
|
|
"name": "Test Payslip AU",
|
|
"employee_id": self.employee_id.id,
|
|
"date_from": today,
|
|
"date_to": today,
|
|
"struct_id": self.struct_regular.id,
|
|
})
|
|
payslip._compute_date_to()
|
|
params = payslip._rule_parameter("l10n_au_medicare_params")[self.employee_id.l10n_au_scale]
|
|
for children in nbr_children:
|
|
self.employee_id.children = children
|
|
for period, sample_data in self.medicare_adjustment_sample_data.items():
|
|
for row in sample_data:
|
|
earnings = row[0]
|
|
self.contract_ids[0].wage = earnings
|
|
amount = payslip._l10n_au_compute_medicare_adjustment(earnings, period, params)
|
|
self.assertEqual(amount, row[children + 1], f"weekly earnings of {earnings} children {self.employee_id.children}: expected {row[children + 1]} got {-amount}")
|
|
|
|
def test_compute_loan_withhold(self):
|
|
today = date.today()
|
|
payslip = self.env["hr.payslip"].create({
|
|
"name": "Test Payslip AU",
|
|
"employee_id": self.employee_id.id,
|
|
"date_from": today,
|
|
"date_to": today,
|
|
"struct_id": self.struct_regular.id,
|
|
})
|
|
payslip._compute_date_to()
|
|
|
|
loan_coefs = payslip._rule_parameter("l10n_au_stsl")
|
|
for period, sample_data in self.loan_withhold_sample_data.items():
|
|
self.employee_id.l10n_au_scale = "1"
|
|
coefs = loan_coefs["1"]
|
|
for row_claimed in sample_data:
|
|
earnings = row_claimed[0]
|
|
expected = row_claimed[2]
|
|
amount = payslip._l10n_au_compute_loan_withhold(earnings, period, coefs)
|
|
self.assertAlmostEqual(amount, expected, delta=1, msg=f"weekly earnings of {earnings} scale {self.employee_id.l10n_au_scale}: expected {expected} got {-amount}")
|
|
self.employee_id.l10n_au_scale = "2"
|
|
coefs = loan_coefs["2"]
|
|
for row_not_claimed in sample_data:
|
|
earnings = row_not_claimed[0]
|
|
expected = row_not_claimed[1]
|
|
amount = payslip._l10n_au_compute_loan_withhold(earnings, period, coefs)
|
|
self.assertAlmostEqual(amount, expected, delta=1, msg=f"weekly earnings of {earnings} scale {self.employee_id.l10n_au_scale}: expected {expected} got {-amount}")
|
|
|
|
def test_general_cases(self):
|
|
# https://www.ato.gov.au/rates/schedule-1---statement-of-formulas-for-calculating-amounts-to-be-withheld/?page=6#General_examples
|
|
# EXAMPLE 1
|
|
self.contract_ids[0].wage = 1103.45
|
|
self.contract_ids[0].schedule_pay = "weekly"
|
|
self.contract_ids[0]._compute_wages()
|
|
self.employee_id.marital = "married"
|
|
self.employee_id.children = 5
|
|
self.employee_id.l10n_au_scale = "2"
|
|
payslip_id = self.env["hr.payslip"].create({
|
|
"name": "payslip",
|
|
"employee_id": self.employee_id.id,
|
|
"contract_id": self.contract_ids[0].id,
|
|
"struct_id": self.struct_regular.id,
|
|
"date_from": date(2023, 9, 18),
|
|
"date_to": date(2023, 9, 23),
|
|
})
|
|
payslip_id.compute_sheet()
|
|
payslip_lines = payslip_id.line_ids
|
|
withholding_amount = payslip_lines.filtered(lambda l: l.code == "WITHHOLD").amount
|
|
adjustment_amount = payslip_lines.filtered(lambda l: l.code == "MEDICARE").amount
|
|
self.assertEqual(-withholding_amount, 198)
|
|
self.assertEqual(adjustment_amount, 20)
|
|
|
|
# EXAMPLE 2
|
|
self.contract_ids[0].wage = 1110.30
|
|
self.contract_ids[0].schedule_pay = "bi-weekly"
|
|
self.contract_ids[0]._compute_wages()
|
|
self.employee_id.marital = "single"
|
|
self.employee_id.children = 0
|
|
self.employee_id.l10n_au_scale = "5"
|
|
self.employee_id.l10n_au_nat_3093_amount = 1645
|
|
payslip_id = self.env["hr.payslip"].create({
|
|
"name": "payslip",
|
|
"employee_id": self.employee_id.id,
|
|
"contract_id": self.contract_ids[0].id,
|
|
"struct_id": self.struct_regular.id,
|
|
"date_from": date(2023, 9, 18),
|
|
"date_to": date(2023, 9, 30),
|
|
})
|
|
payslip_id.compute_sheet()
|
|
payslip_lines = payslip_id.line_ids
|
|
withholding_amount = payslip_lines.filtered(lambda l: l.code == "WITHHOLD").amount
|
|
tax_offset = payslip_lines.filtered(lambda l: l.code == "TAX.OFFSET").amount
|
|
self.assertEqual(-withholding_amount, 74)
|
|
self.assertEqual(tax_offset, 63)
|
|
|
|
# EXAMPLE 3
|
|
|
|
self.contract_ids[0].wage = 4500.33
|
|
self.contract_ids[0].schedule_pay = "monthly"
|
|
self.contract_ids[0]._compute_wages()
|
|
self.employee_id.marital = "married"
|
|
self.employee_id.children = 1
|
|
self.employee_id.l10n_au_scale = "2"
|
|
self.employee_id.l10n_au_nat_3093_amount = 1365
|
|
payslip_id = self.env["hr.payslip"].create({
|
|
"name": "payslip",
|
|
"employee_id": self.employee_id.id,
|
|
"contract_id": self.contract_ids[0].id,
|
|
"struct_id": self.struct_regular.id,
|
|
"date_from": date(2023, 9, 1),
|
|
"date_to": date(2023, 9, 30),
|
|
})
|
|
payslip_id.compute_sheet()
|
|
payslip_lines = payslip_id.line_ids
|
|
withholding_amount = payslip_lines.filtered(lambda l: l.code == "WITHHOLD").amount
|
|
tax_offset = payslip_lines.filtered(lambda l: l.code == "TAX.OFFSET").amount
|
|
self.assertEqual(-withholding_amount, 758)
|
|
self.assertEqual(tax_offset, 113)
|
|
|
|
def lines_by_code(self, lines):
|
|
lines_by_code = defaultdict(lambda: {"lines": [], "amount": 0, "total": 0})
|
|
for line in lines:
|
|
lines_by_code[line.code]["lines"].append(line)
|
|
lines_by_code[line.code]["amount"] += line.amount
|
|
lines_by_code[line.code]["total"] += line.total
|
|
return lines_by_code
|
|
|
|
def create_employee_and_contract(self, wage, period):
|
|
employee_id = self.env["hr.employee"].create({
|
|
"name": "Mel",
|
|
"resource_calendar_id": self.resource_calendar.id,
|
|
"company_id": self.australian_company.id,
|
|
"private_street": "1 Test Street",
|
|
"private_city": "Sydney",
|
|
"private_country_id": self.env.ref("base.au").id,
|
|
"work_phone": "123456789",
|
|
"birthday": date.today() - relativedelta(years=22),
|
|
# fields modified in the tests
|
|
"marital": "single",
|
|
"l10n_au_tfn_declaration": "provided",
|
|
"l10n_au_tfn": "12345678",
|
|
"l10n_au_tax_free_threshold": True,
|
|
"is_non_resident": False,
|
|
"l10n_au_training_loan": False,
|
|
"l10n_au_nat_3093_amount": 0,
|
|
"l10n_au_child_support_garnishee_amount": 0,
|
|
"l10n_au_medicare_exemption": "X",
|
|
"l10n_au_medicare_surcharge": "X",
|
|
"l10n_au_medicare_reduction": "X",
|
|
"l10n_au_child_support_deduction": 0,
|
|
"l10n_au_scale": "2",
|
|
})
|
|
|
|
contract_id = self.env["hr.contract"].create({
|
|
"name": "Mel's contract",
|
|
"employee_id": employee_id.id,
|
|
"resource_calendar_id": self.resource_calendar.id,
|
|
"company_id": self.australian_company.id,
|
|
"date_start": date(2023, 1, 1),
|
|
"date_end": False,
|
|
"wage_type": "monthly",
|
|
"wage": wage,
|
|
"l10n_au_casual_loading": 0.0,
|
|
"structure_type_id": self.env.ref("l10n_au_hr_payroll.structure_type_schedule_1").id,
|
|
# fields modified in the tests
|
|
"schedule_pay": period,
|
|
"l10n_au_employment_basis_code": "F",
|
|
"l10n_au_income_stream_type": "SAW",
|
|
"l10n_au_withholding_variation": False,
|
|
"l10n_au_withholding_variation_amount": 0,
|
|
"l10n_au_workplace_giving": 0,
|
|
"l10n_au_tax_treatment_category": "R",
|
|
"l10n_au_tax_treatment_option": "T",
|
|
})
|
|
employee_id.contract_id = contract_id
|
|
return employee_id, contract_id
|
|
|
|
def test_withholding_monthly_regular_employee(self):
|
|
employee_id, contract_id = self.create_employee_and_contract(5000, "monthly")
|
|
no_tfn_structure_type = self.env.ref("l10n_au_hr_payroll.structure_type_no_tfn")
|
|
payslip_id = self.env["hr.payslip"].create({
|
|
"name": "payslip",
|
|
"employee_id": employee_id.id,
|
|
"contract_id": contract_id.id,
|
|
"struct_id": self.struct_regular.id,
|
|
"date_from": date(2023, 7, 1),
|
|
"date_to": date(2023, 7, 31),
|
|
})
|
|
|
|
# Scenario 1: Tax free threshold claimed
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 932, "test scenario 1: tax free threshold claimed")
|
|
|
|
# Scenario 2: Tax free threshold not claimed
|
|
employee_id.l10n_au_tax_free_threshold = False
|
|
self.assertEqual(employee_id.l10n_au_scale, "1")
|
|
self.assertEqual(employee_id.contract_id.l10n_au_tax_treatment_option, "N")
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 1456, "test scenario 2: tax free threshold not claimed")
|
|
employee_id.l10n_au_tax_free_threshold = True
|
|
|
|
# Scenario 3: Foreign resident
|
|
employee_id.is_non_resident = True
|
|
self.assertEqual(employee_id.l10n_au_scale, "3")
|
|
self.assertEqual(employee_id.contract_id.l10n_au_tax_treatment_option, "T")
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 1625, "test scenario 3: foreign resident")
|
|
employee_id.is_non_resident = False
|
|
|
|
# Scenario 4: HELP / STSL Loan
|
|
employee_id.l10n_au_training_loan = True
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 1032, "test scenario 4: HELP / STSL Loan")
|
|
employee_id.l10n_au_training_loan = False
|
|
|
|
# Scenario 5: Tax offset
|
|
employee_id.l10n_au_nat_3093_amount = 100
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 924, "test scenario 5: Tax offset of 100")
|
|
employee_id.l10n_au_nat_3093_amount = 0
|
|
|
|
# Scenario 6: Half medicare exemption
|
|
employee_id.l10n_au_medicare_exemption = "H"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 880, "test scenario 6: Half medicare exemption")
|
|
|
|
# Scenario 7: Full medicare exemption
|
|
employee_id.l10n_au_medicare_exemption = "F"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 832, "test scenario 7: Full medicare exemption")
|
|
employee_id.l10n_au_medicare_exemption = "X"
|
|
|
|
# Scenario 9: Medicare surcharge
|
|
employee_id.l10n_au_tfn_declaration = "000000000"
|
|
employee_id.contract_id.structure_type_id = self.env.ref("l10n_au_hr_payroll.structure_type_no_tfn")
|
|
payslip_id.struct_id = self.env.ref("l10n_au_hr_payroll.hr_payroll_structure_au_no_tfn")
|
|
self.assertEqual(employee_id.contract_id.structure_type_id, no_tfn_structure_type)
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 2350, "test scenario 9: TFN not provided")
|
|
|
|
# Scenario 10: TFN applied for but not provided, less than 28 days ago
|
|
employee_id.l10n_au_tfn_declaration = "111111111"
|
|
# structure_type was no tfn from previous test, make sure that changing declaration to a valid tfn does not change the structure
|
|
# because this has to be done manually by the payroll agent
|
|
self.assertEqual(employee_id.contract_id.structure_type_id, no_tfn_structure_type)
|
|
payslip_id.contract_id.structure_type_id = self.env.ref("l10n_au_hr_payroll.structure_type_schedule_1")
|
|
payslip_id.struct_id = self.struct_regular
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 932, "test scenario 10: TFN applied for but not provided, less than 28 days ago")
|
|
|
|
# Scenario 11: Employee under 18, and earns less than 350$ weekly
|
|
employee_id.l10n_au_tfn_declaration = "333333333"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 932, "test scenario 11: Employee under 18, and earns less than 350$ weekly")
|
|
|
|
# Scenario 12: Exempt from TFN
|
|
employee_id.l10n_au_tfn_declaration = "444444444"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 932, "test scenario 12: Exempt from TFN")
|
|
|
|
# Scenario 13: 4 children, medicare reduction
|
|
employee_id.write({
|
|
"l10n_au_tfn_declaration": "provided",
|
|
"l10n_au_tfn": "12345678",
|
|
"marital": "married",
|
|
"children": 4,
|
|
})
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 893, "test scenario 13: 4 children, medicare reduction")
|
|
employee_id.write({
|
|
"l10n_au_tfn_declaration": "provided",
|
|
"l10n_au_tfn": "12345678",
|
|
# kill the wife
|
|
"marital": "single",
|
|
# kill the children
|
|
"children": 0,
|
|
})
|
|
|
|
# Scenario 14: Withholding variation
|
|
payslip_id.contract_id.write({
|
|
"l10n_au_withholding_variation": True,
|
|
"l10n_au_withholding_variation_amount": 15,
|
|
})
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 750, "test scenario 14: Withholding variation")
|
|
payslip_id.contract_id.write({
|
|
"l10n_au_withholding_variation": False,
|
|
})
|
|
|
|
def test_withholding_weekly_regular_employee(self):
|
|
employee_id, contract_id = self.create_employee_and_contract(1000, "weekly")
|
|
no_tfn_structure_type = self.env.ref("l10n_au_hr_payroll.structure_type_no_tfn")
|
|
payslip_id = self.env["hr.payslip"].create({
|
|
"name": "payslip",
|
|
"employee_id": employee_id.id,
|
|
"contract_id": contract_id.id,
|
|
"struct_id": self.struct_regular.id,
|
|
"date_from": date(2023, 7, 1),
|
|
"date_to": date(2023, 7, 7),
|
|
})
|
|
|
|
# Scenario 26: Tax free threshold claimed
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 162, "test scenario 26: tax free threshold claimed")
|
|
|
|
# Scenario 27: Tax free threshold not claimed
|
|
employee_id.l10n_au_tax_free_threshold = False
|
|
self.assertEqual(employee_id.l10n_au_scale, "1")
|
|
self.assertEqual(employee_id.contract_id.l10n_au_tax_treatment_option, "N")
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 283, "test scenario 27: tax free threshold not claimed")
|
|
employee_id.l10n_au_tax_free_threshold = True
|
|
|
|
# Scenario 28: Foreign resident
|
|
employee_id.is_non_resident = True
|
|
self.assertEqual(employee_id.l10n_au_scale, "3")
|
|
self.assertEqual(employee_id.contract_id.l10n_au_tax_treatment_option, "T")
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 325, "test scenario 28: foreign resident")
|
|
employee_id.is_non_resident = False
|
|
|
|
# Scenario 29: HELP / STSL Loan
|
|
employee_id.l10n_au_training_loan = True
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 172, "test scenario 29: HELP / STSL Loan")
|
|
employee_id.l10n_au_training_loan = False
|
|
|
|
# Scenario 30: Tax offset
|
|
employee_id.l10n_au_nat_3093_amount = 100
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 160, "test scenario 30: Tax offset of 100")
|
|
employee_id.l10n_au_nat_3093_amount = 0
|
|
|
|
# Scenario 31: Half medicare exemption
|
|
employee_id.l10n_au_medicare_exemption = "H"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 152, "test scenario 31: Half medicare exemption")
|
|
|
|
# Scenario 32: Full medicare exemption
|
|
employee_id.l10n_au_medicare_exemption = "F"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 142, "test scenario 32: Full medicare exemption")
|
|
employee_id.l10n_au_medicare_exemption = "X"
|
|
|
|
# Scenario 34: Medicare surcharge
|
|
employee_id.l10n_au_tfn_declaration = "000000000"
|
|
employee_id.contract_id.structure_type_id = self.env.ref("l10n_au_hr_payroll.structure_type_no_tfn")
|
|
payslip_id.struct_id = self.env.ref("l10n_au_hr_payroll.hr_payroll_structure_au_no_tfn")
|
|
self.assertEqual(employee_id.contract_id.structure_type_id, no_tfn_structure_type)
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 470, "test scenario 34: TFN not provided")
|
|
|
|
# Scenario 35: TFN applied for but not provided, less than 28 days ago
|
|
employee_id.l10n_au_tfn_declaration = "111111111"
|
|
# structure_type was no tfn from previous test, make sure that changing declaration to a valid tfn does not change the structure
|
|
# because this has to be done manually by the payroll agent
|
|
self.assertEqual(employee_id.contract_id.structure_type_id, no_tfn_structure_type)
|
|
payslip_id.contract_id.structure_type_id = self.env.ref("l10n_au_hr_payroll.structure_type_schedule_1")
|
|
payslip_id.struct_id = self.struct_regular
|
|
self.assertEqual(payslip_id.worked_days_line_ids.amount, 1000)
|
|
payslip_id.contract_id.schedule_pay = "weekly"
|
|
payslip_id.compute_sheet()
|
|
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 162, "test scenario 35: TFN applied for but not provided, less than 28 days ago")
|
|
|
|
# Scenario 36: Employee under 18, and earns less than 350$ weekly
|
|
employee_id.l10n_au_tfn_declaration = "333333333"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 162, "test scenario 36: Employee under 18, and earns less than 350$ weekly")
|
|
|
|
# Scenario 37: Exempt from TFN
|
|
employee_id.l10n_au_tfn_declaration = "444444444"
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 162, "test scenario 37: Exempt from TFN")
|
|
|
|
# Scenario 38: 4 children, medicare reduction
|
|
employee_id.write({
|
|
"l10n_au_tfn_declaration": "provided",
|
|
"l10n_au_tfn": "12345678",
|
|
"marital": "married",
|
|
"children": 4,
|
|
})
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 142, "test scenario 38: 4 children, medicare reduction")
|
|
employee_id.write({
|
|
"l10n_au_tfn_declaration": "provided",
|
|
"l10n_au_tfn": "12345678",
|
|
# kill the wife
|
|
"marital": "single",
|
|
# kill the children
|
|
"children": 0,
|
|
})
|
|
|
|
# Scenario 39: Withholding variation
|
|
payslip_id.contract_id.write({
|
|
"l10n_au_withholding_variation": True,
|
|
"l10n_au_withholding_variation_amount": 15,
|
|
})
|
|
payslip_id.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_id.line_ids)
|
|
self.assertEqual(-lbc["WITHHOLD.TOTAL"]["total"], 150, "test scenario 39: Withholding variation")
|
|
payslip_id.contract_id.write({
|
|
"l10n_au_withholding_variation": False,
|
|
})
|
|
|
|
def test_termination_payment_unused_leaves(self):
|
|
employee_id, contract_id = self.create_employee_and_contract(5000, "monthly")
|
|
# Allocate Holidays
|
|
self.env['hr.leave.allocation'].create([{
|
|
'name': 'Paid Time Off 2023',
|
|
'holiday_status_id': self.env.ref('l10n_au_hr_payroll.hr_leave_type_annual_au').id,
|
|
'number_of_days': 15,
|
|
'employee_id': employee_id.id,
|
|
'state': 'confirm',
|
|
'date_from': date(2023, 1, 1),
|
|
'date_to': date(2023, 12, 31),
|
|
}]).action_validate()
|
|
|
|
payslip_term = self.env["hr.payslip"].create({
|
|
"name": "Termination Payment",
|
|
"employee_id": employee_id.id,
|
|
"contract_id": contract_id.id,
|
|
"struct_id": self.env.ref("l10n_au_hr_payroll.hr_payroll_structure_au_termination").id,
|
|
"l10n_au_termination_type": "genuine",
|
|
"date_from": date(2023, 8, 1),
|
|
"date_to": date(2023, 8, 31),
|
|
"input_line_ids": [
|
|
Command.create({'input_type_id': self.env.ref('l10n_au_hr_payroll.input_severance_pay').id, 'amount': 15000}),
|
|
Command.create({'input_type_id': self.env.ref('l10n_au_hr_payroll.input_golden_handshake').id, 'amount': 20000}),
|
|
Command.create({'input_type_id': self.env.ref('l10n_au_hr_payroll.input_genuine_redundancy').id, 'amount': 5000}),
|
|
]
|
|
})
|
|
# print(payslip_term.input_line_ids.read(['input_type_id']))
|
|
# Scenario 1: Tax free threshold claimed
|
|
payslip_term.compute_sheet()
|
|
lbc = self.lines_by_code(payslip_term.line_ids)
|
|
self.assertEqual(lbc["LEAVE"]["total"], 3461.54, "Incorrect Leave base")
|
|
self.assertEqual(-lbc["LEAVE.WITHHOLD"]["total"], 1108, "Withhold incorrect for genuine redundancy.")
|