feat(vacation): 연차 12/31 소멸 삭제 — 입사일 기준, 연차마다 쓸 수 있는 기한

- store.leave_grants/leave_period/leave_status: 1년 미만 월 1일 = 입사일부터 1년까지, 근속 n년 연차 = 생긴 날부터 1년까지(근로기준법 제60조)
- 승인된 연차·반차를 날짜별(usage_units = compute_days 규칙)로 나눠 그날 쓸 수 있는 연차 중 먼저 소멸하는 것부터 차감, 생기기 전이면 당겨 씀
- 화면: 지금 연차 기간 · 생기는 연차(오늘까지 +앞으로) · 사용 · 오늘 쓸 수 있는 잔여 · 먼저 소멸(날짜·일수), 해 이동 없음, 달력 위 내 연차도 같은 값
- 직접 입력 = 지금 연차 기간이 시작한 해 줄(override_year), 시스템 전 사용 = 2026 줄(도입일에 쓴 것으로)
- 테스트: 규칙(10/12 입사 사례·먼저 소멸·당겨 씀·시스템 전·입사일 없음), 실제 PG, 실제 앱, 브라우저

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-26 16:27:50 +09:00
parent 197c3c13a3
commit 4b2defac3a
16 changed files with 500 additions and 311 deletions
+119 -61
View File
@@ -108,72 +108,127 @@ class VacationHolidayBalanceDBTests(unittest.TestCase):
self.st.approve(request_id=req["id"], approver_email="lee@test.local")
return req
def test_used_days_only_annual_types_and_split_by_year(self):
def test_usage_only_annual_types_and_hire_based_status(self):
"""승인된 연차·반차만 쓴 날로(병가·경조·제출 제외), 입사일 기준으로 먼저 소멸할 연차부터 뺀다(2026-10-27 — 12/31 소멸 없음)."""
from datetime import date
st = self.st
owner = f"bal-{uuid.uuid4().hex[:6]}@test.local"
made = [
self._approved(owner, "연차", "2026-11-02", "2026-11-03"), # 2
self._approved(owner, "오전반차", "2026-11-04", "2026-11-04"), # 0.5
self._approved(owner, "병가", "2026-11-05", "2026-11-06"), # 차감 안 함
self._approved(owner, "경조", "2026-11-09", "2026-11-09"), # 차감 안 함
self._approved(owner, "연차", "2026-12-30", "2027-01-04"), # 12/30·31 = 2, 1/4 = 1 (1/1 신정·주말 뺌)
]
st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함
self._approved(owner, "연차", "2026-11-02", "2026-11-03") # 2
self._approved(owner, "오전반차", "2026-11-04", "2026-11-04") # 0.5
self._approved(owner, "병가", "2026-11-05", "2026-11-06") # 차감 안 함
self._approved(owner, "경조", "2026-11-09", "2026-11-09") # 차감 안 함
self._approved(owner, "연차", "2026-12-30", "2027-01-04") # 12/30·31·1/4 = 3 (1/1 신정·주말 뺌)
st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함
payload={"vacation_type": "연차", "start_date": "2026-11-10", "end_date": "2026-11-10",
"start_half": "full", "end_half": "full", "reason": ""})
try:
self.assertEqual(st.used_days(user_email=owner, year=2026), 4.5)
self.assertEqual(st.used_days(user_email=owner, year=2027), 1.0)
st.save_balances(year=2026, rows=[{"user_email": owner, "total_days": 15, "memo": "입사 2020"}])
s26 = st.balance_summary(user_email=owner, year=2026)
self.assertEqual((s26["total_days"], s26["used_days"], s26["remaining_days"]), (15.0, 4.5, 10.5))
s27 = st.balance_summary(user_email=owner, year=2027) # 다음 해로 넘어가지 않음(등록 전 = 0)
self.assertEqual((s27["total_days"], s27["remaining_days"]), (0.0, -1.0))
ev = st.usage_events(user_email=owner)
self.assertEqual(round(sum(a for d, a in ev), 2), 5.5)
self.assertEqual((st.used_days(user_email=owner, year=2026), st.used_days(user_email=owner, year=2027)), (4.5, 1.0))
# 입사 2020-03-02 → 2026-03-02 근속 6년 17일(2027-03-01 까지) — 12/31 에 안 없어짐
st.save_balances(rows=[{"user_email": owner, "total_days": None, "memo": "", "hire_date": "2020-03-02"}],
as_of=date(2026, 10, 27))
s1 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27))
self.assertEqual((s1["period_start"], s1["period_end"], s1["granted"], s1["used"], s1["available"]),
("2026-03-02", "2027-03-01", 17.0, 5.5, 11.5)) # 앞날짜 승인 휴가도 이미 차감
self.assertEqual(s1["expiring"], {"date": "2027-03-01", "days": 11.5})
s2 = st.balance_summary(user_email=owner, as_of=date(2027, 2, 1)) # 해가 바뀌어도 그대로
self.assertEqual(s2["available"], 11.5)
s3 = st.balance_summary(user_email=owner, as_of=date(2027, 3, 2)) # 근속 7년 18일 새로
self.assertEqual((s3["granted"], s3["available"], s3["used"]), (18.0, 18.0, 0.0))
# 직접 입력 = 이번 연차 기간(2026-03-02 시작 → 2026 줄) 법정 대신
st.save_balances(rows=[{"user_email": owner, "total_days": 20, "memo": "회사 기준"}], as_of=date(2026, 10, 27))
self.assertEqual(st.get_balance(user_email=owner, year=2026)["total_days"], 20.0)
s4 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27))
self.assertEqual((s4["granted"], s4["available"], s4["manual_total"], s4["memo"]), (20.0, 14.5, 20.0, "회사 기준"))
finally:
for r in st.list_for(owner):
st.hard_delete(request_id=r["id"], user_email=owner, is_admin=True)
def test_save_balances_validates_all_or_nothing(self):
from datetime import date
st = self.st
a, b = f"a-{uuid.uuid4().hex[:6]}@test.local", f"b-{uuid.uuid4().hex[:6]}@test.local"
on = date(2031, 5, 1) # 입사일 없음 → 직접 입력은 그해(2031) 줄
with self.assertRaises(ValueError):
st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}])
self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함
self.assertEqual(st.save_balances(year=2031, rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "},
{"user_email": b, "total_days": 0}]), 2)
st.save_balances(rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}], as_of=on)
self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함
self.assertEqual(st.save_balances(rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "},
{"user_email": b, "total_days": 0}], as_of=on), 2)
self.assertEqual((st.get_balance(user_email=a, year=2031)["total_days"], st.get_balance(user_email=a, year=2031)["memo"]),
(15.5, "x"))
st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 20, "memo": ""}]) # 덮어쓰기
st.save_balances(rows=[{"user_email": a, "total_days": 20, "memo": ""}], as_of=on) # 덮어쓰기
self.assertEqual(st.get_balance(user_email=a, year=2031)["total_days"], 20.0)
class LegalAnnualLeaveTests(unittest.TestCase):
"""근로기준법 제60조 — 입사일 기준으로 생기는 연차를 그해에 모은다(2026-10-27, DB 없음)."""
class LeaveRulesTests(unittest.TestCase):
"""근로기준법 제60조 — 입사일 기준, 연차마다 쓸 수 있는 기한(2026-10-27, 12/31 소멸 없음, DB 없음)."""
def test_rules(self):
from datetime import date
def test_grants_periods_and_usage_units(self):
from datetime import date as D
from app.modules.vacation.store import add_months, legal_annual_leave as L
from app.modules.vacation.store import add_months, compute_days, leave_grants, leave_period, usage_units
self.assertEqual(add_months(date(2026, 1, 31), 1), date(2026, 2, 28))
self.assertEqual(add_months(date(2024, 2, 29), 12), date(2025, 2, 28))
# 입사 1년 미만 = 1개월마다 1일, 입사일이 돌아오면 15일 — 2025-03-01 입사
self.assertEqual(L(date(2025, 3, 1), 2025)["days"], 9.0) # 4/1 ~ 12/1
r = L(date(2025, 3, 1), 2026)
self.assertEqual((r["days"], r["service_years"]), (17.0, 1)) # 1/1·2/1(월 1일) + 3/1 근속 1년 15일
self.assertEqual([i["date"] for i in r["items"]], ["2026-01-01", "2026-02-01", "2026-03-01"])
self.assertEqual(L(date(2025, 3, 1), 2027)["days"], 15.0) # 근속 2년 = 15일
# 3년 이상 = 최초 1년을 넘는 근속 2년마다 1일, 최대 25일
self.assertEqual(L(date(2023, 5, 10), 2026)["days"], 16.0) # 근속 3년
self.assertEqual(L(date(2020, 3, 2), 2026)["days"], 17.0) # 근속 6년 = 15 + 2
self.assertEqual(L(date(2001, 1, 1), 2026)["days"], 25.0) # 근속 25년 → 한도 25
self.assertEqual(L(date(2027, 1, 2), 2026)["days"], 0.0) # 아직 입사 전
self.assertEqual(L(None, 2026)["days"], 0.0)
self.assertEqual(add_months(D(2026, 1, 31), 1), D(2026, 2, 28))
self.assertEqual(add_months(D(2024, 2, 29), 12), D(2025, 2, 28))
g = leave_grants(D(2026, 10, 12), D(2027, 10, 12))
self.assertEqual([(x["date"].isoformat(), x["days"], x["expires"].isoformat()) for x in g[:2]],
[("2026-11-12", 1.0, "2027-10-11"), ("2026-12-12", 1.0, "2027-10-11")]) # 월 1일 = 입사일부터 1년까지
self.assertEqual(len([x for x in g if x["period"] == 0]), 11)
self.assertEqual((g[-1]["date"], g[-1]["days"], g[-1]["expires"]), (D(2027, 10, 12), 15.0, D(2028, 10, 11)))
days = {x["period"]: x["days"] for x in leave_grants(D(2001, 1, 1), D(2026, 12, 31)) if x["period"]}
self.assertEqual((days[1], days[2], days[3], days[5], days[6], days[21], days[25]), (15.0, 15.0, 16.0, 17.0, 17.0, 25.0, 25.0))
self.assertEqual(leave_period(D(2026, 10, 12), D(2026, 10, 26)), (0, D(2026, 10, 12), D(2027, 10, 11)))
self.assertEqual(leave_period(D(2020, 3, 2), D(2026, 10, 26)), (6, D(2026, 3, 2), D(2027, 3, 1)))
hol = {"2027-01-01"}
for kw in ({"start_date": D(2026, 12, 30), "end_date": D(2027, 1, 4), "start_half": "pm", "end_half": "am"},
{"start_date": D(2026, 11, 4), "end_date": D(2026, 11, 4), "vacation_type": "오전반차"},
{"start_date": D(2026, 11, 7), "end_date": D(2026, 11, 8)}):
self.assertEqual(sum(a for d, a in usage_units(holidays=hol, **kw)), compute_days(holidays=hol, **kw), kw)
def test_status_oct12_hire(self):
"""10/12 입사 — 오늘(10/26) 쓸 수 있는 연차 0, 이번 기간(~2027-10-11) 11일 생김, 1년 되면 15일(~2028-10-11)."""
from datetime import date as D
from app.modules.vacation.store import leave_status as S
h = D(2026, 10, 12)
r = S(hire=h, as_of=D(2026, 10, 26), usages=[])
self.assertEqual((r["granted"], r["granted_so_far"], r["upcoming"], r["available"], r["expiring"]), (11.0, 0.0, 11.0, 0.0, None))
r = S(hire=h, as_of=D(2026, 12, 20), usages=[(D(2026, 12, 15), 1.0)])
self.assertEqual((r["granted_so_far"], r["used"], r["available"], r["expiring"]), (2.0, 1.0, 1.0, {"date": "2027-10-11", "days": 1.0}))
r = S(hire=h, as_of=D(2027, 1, 5), usages=[(D(2026, 12, 15), 1.0)]) # 해가 바뀌어도 그대로 + 1/12 전
self.assertEqual(r["available"], 1.0)
r = S(hire=h, as_of=D(2027, 10, 12), usages=[(D(2026, 12, 15), 1.0)]) # 남은 월차 10일은 10/11 에 소멸
self.assertEqual((r["service_years"], r["granted"], r["available"], r["expiring"]), (1, 15.0, 15.0, {"date": "2028-10-11", "days": 15.0}))
r = S(hire=h, as_of=D(2026, 10, 26), usages=[(D(2026, 10, 20), 1.0)]) # 생기기 전에 씀 = 당겨 씀
self.assertEqual(r["available"], -1.0)
def test_status_first_expiring_used_first_prior_and_no_hire(self):
from datetime import date as D
from app.modules.vacation.store import leave_status as S
# 2025-11-01 입사: 2026-10-01 까지 월차(~2026-10-31), 2026-11-01 15일 — 10/30 에 쓴 1일은 곧 소멸할 월차에서
h = D(2025, 11, 1)
r = S(hire=h, as_of=D(2026, 10, 30), usages=[(D(2026, 10, 30), 1.0)])
self.assertEqual((r["available"], r["expiring"]), (10.0, {"date": "2026-10-31", "days": 10.0}))
r = S(hire=h, as_of=D(2026, 11, 2), usages=[(D(2026, 10, 30), 1.0)])
self.assertEqual((r["available"], r["used"]), (15.0, 0.0)) # 새 기간 15일 그대로
# 시스템 전 사용 = 도입일(2026-10-27)에 쓴 것으로
r = S(hire=D(2020, 3, 2), as_of=D(2026, 10, 28), usages=[], prior=4.5)
self.assertEqual((r["used"], r["available"]), (4.5, 12.5))
# 입사일 없음 + 직접 입력 = 그해 연차(소멸일 없음 — 입사일을 넣어야 계산)
r = S(hire=None, as_of=D(2026, 10, 28), usages=[(D(2026, 5, 4), 1.0), (D(2025, 5, 4), 1.0)], override=15)
self.assertEqual((r["granted"], r["used"], r["available"], r["expiring"], r["has_hire"]), (15.0, 1.0, 14.0, None, False))
self.assertEqual(S(hire=None, as_of=D(2026, 10, 28), usages=[])["available"], 0.0)
@unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정")
class VacationHireDBTests(unittest.TestCase):
"""002 — 입사일·시스템 전 사용·연차 비우면 법정(실제 PostgreSQL, 002 적용 DB)."""
"""002 — 입사일·시스템 전 사용·직접 입력(실제 PostgreSQL, 002 적용 DB)."""
@classmethod
def setUpClass(cls):
@@ -185,33 +240,36 @@ class VacationHireDBTests(unittest.TestCase):
def tearDownClass(cls):
cls.st.close()
def test_hire_legal_manual_prior(self):
def test_hire_prior_and_override_rows(self):
from datetime import date
st = self.st
on = date(2026, 10, 28)
self.assertTrue(st.hire_ready())
a, b = f"h-{uuid.uuid4().hex[:6]}@test.local", f"h-{uuid.uuid4().hex[:6]}@test.local"
n = st.save_balances(year=2026, by="admin@test.local", rows=[
{"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2025-03-01"},
{"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2020-03-02"},
n = st.save_balances(by="admin@test.local", as_of=on, rows=[
{"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2026-10-12"},
{"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2024-11-15"},
])
self.assertEqual(n, 2)
self.assertEqual(st.hire_dates()[a], "2025-03-01")
sa = st.balance_summary(user_email=a, year=2026)
self.assertEqual((sa["total_days"], sa["manual_total"], sa["legal_days"], sa["prior_used"], sa["remaining_days"]),
(17.0, None, 17.0, 3.5, 13.5)) # 법정 17 − 시스템 전 3.5
sb = st.balance_summary(user_email=b, year=2026)
self.assertEqual((sb["total_days"], sb["legal_days"], sb["remaining_days"], sb["service_years"]), (20.0, 17.0, 20.0, 6))
# 2027 — 아무것도 등록 안 해도 입사일로 법정 연차(이월 없음)
self.assertEqual(st.balance_summary(user_email=a, year=2027)["total_days"], 15.0)
# 입사일 지우기("") · 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}])
self.assertEqual(st.hire_dates()[a], "2025-03-01")
self.assertEqual(st.hire_dates()[a], "2026-10-12")
sa = st.balance_summary(user_email=a, as_of=on) # 10/12 입사 — 아직 생긴 연차 없음, 시스템 전 사용 3.5 = 당겨 씀
self.assertEqual((sa["granted"], sa["granted_so_far"], sa["available"], sa["prior_used"]), (11.0, 0.0, -3.5, 3.5))
# b: 2025-11-15 근속 1년 기간(2025 줄)에 직접 입력 20, 시스템 전 사용은 2026 줄
self.assertEqual(st.get_balance(user_email=b, year=2025)["total_days"], 20.0)
sb = st.balance_summary(user_email=b, as_of=on)
self.assertEqual((sb["period_start"], sb["granted"], sb["available"], sb["key_year"]), ("2025-11-15", 20.0, 20.0, 2025))
self.assertEqual(st.balance_summary(user_email=b, as_of=date(2026, 11, 16))["granted"], 15.0) # 다음 기간 = 법정 15
# 입사일 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 · "" = 지움
st.save_balances(rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2026-10-12")
with self.assertRaises(ValueError):
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""},
{"user_email": b, "total_days": None, "hire_date": "2020-13-01"}])
self.assertEqual(st.hire_dates()[a], "2025-03-01")
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""}])
st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""},
{"user_email": b, "total_days": None, "hire_date": "2020-13-01"}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2026-10-12")
st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""}], as_of=on)
self.assertNotIn(a, st.hire_dates())
self.assertEqual(st.balance_summary(user_email=a, year=2026)["total_days"], 0.0)
self.assertEqual(st.balance_summary(user_email=a, as_of=on)["available"], 0.0)
if __name__ == "__main__":