97f4a904cd
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
337 lines
23 KiB
Python
337 lines
23 KiB
Python
"""휴가 DB(vacation_db) — 옵션·메일 기록(마이그레이션 001, 2026-10-27) 실제 PostgreSQL 확인.
|
|
|
|
VACATION_TEST_DB_URL 이 localhost/127.0.0.1 일 때만 돈다(아니면 skip). 앱 계정(vacation_app)으로 접속해 권한(GRANT)까지 본다.
|
|
psql … -v app_password=… -f scripts/sql/vacation_db_init.sql
|
|
psql … -d vacation_db -f scripts/sql/vacation_db_001_options_mail.sql
|
|
psql … -d vacation_db -f scripts/sql/vacation_db_003_consults.sql
|
|
VACATION_TEST_DB_URL=postgresql://vacation_app:<pw>@localhost:55432/vacation_db python -m pytest tests/test_vacation_db.py
|
|
"""
|
|
import os
|
|
import sys
|
|
import unittest
|
|
import uuid
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
from urllib.parse import urlparse
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT))
|
|
|
|
DSN = os.getenv("VACATION_TEST_DB_URL", "")
|
|
ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
|
|
|
|
|
|
@unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정")
|
|
class VacationOptionsDBTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from app.modules.vacation.db import VacationDBStore
|
|
|
|
cls.st = VacationDBStore(DSN)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.st.close()
|
|
|
|
def test_options_roundtrip(self):
|
|
self.assertTrue(self.st.options_ready())
|
|
saved = self.st.save_options(approvers=[" Lee@Test.local", "lee@test.local", "boss@test.local", "x"],
|
|
notifiers=["HR@test.local"], by="Admin@Test.local")
|
|
self.assertEqual(saved["approvers"], ["lee@test.local", "boss@test.local"]) # 소문자·중복·@ 없는 값 정리
|
|
self.assertEqual(saved["notifiers"], ["hr@test.local"])
|
|
self.assertEqual(saved["updated_by"], "admin@test.local")
|
|
self.assertTrue(saved["ready"] and saved["updated_at"])
|
|
again = self.st.save_options(approvers=[], notifiers=[], by="admin@test.local") # 덮어쓰기(키 하나)
|
|
self.assertEqual((again["approvers"], again["notifiers"]), ([], []))
|
|
|
|
def _consult_req(self, owner, status="제출"):
|
|
return self.st.create_request(
|
|
owner=owner, owner_name="김철수", status=status,
|
|
payload={"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-06", "start_half": "full", "end_half": "full", "reason": "x"},
|
|
consults=[{"email": "park@test.local", "name": "박과장", "message": "박 내용"},
|
|
{"email": "choi@test.local", "name": "최대리", "message": "최 내용"}])
|
|
|
|
def test_consult_all_approve_moves_to_approver(self):
|
|
"""협의자(003) — 모두 승인해야 결재자에게, 그 전엔 승인 못 함, 내 협의 목록·권한."""
|
|
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
|
|
req = self._consult_req(owner)
|
|
rid = req["id"]
|
|
self.assertEqual(req["status"], "협의중")
|
|
self.assertEqual([(c["email"], c["message"], c["state"]) for c in self.st.list_consults(request_id=rid)],
|
|
[("park@test.local", "박 내용", "대기"), ("choi@test.local", "최 내용", "대기")])
|
|
with self.assertRaises(ValueError): # 협의 중에는 결재자가 승인 못 함
|
|
self.st.approve(request_id=rid, approver_email="lee@test.local")
|
|
self.assertNotIn(rid, [r["id"] for r in self.st.list_pending()])
|
|
self.assertIn(rid, [r["id"] for r in self.st.my_consults(email="PARK@test.local")])
|
|
with self.assertRaises(PermissionError):
|
|
self.st.decide_consult(request_id=rid, email="nobody@test.local", approve=True)
|
|
got, event = self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
|
|
self.assertEqual((got["status"], event), ("협의중", None)) # 한 명 남음
|
|
self.assertNotIn(rid, [r["id"] for r in self.st.my_consults(email="park@test.local")])
|
|
with self.assertRaises(ValueError): # 같은 사람이 두 번은 못 함
|
|
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
|
|
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=True)
|
|
self.assertEqual((got["status"], event), ("제출", "consulted"))
|
|
self.assertIn(rid, [r["id"] for r in self.st.list_pending()])
|
|
self.assertEqual(self.st.approve(request_id=rid, approver_email="lee@test.local")["status"], "승인")
|
|
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=True)
|
|
self.assertEqual(self.st.list_consults(request_id=rid), []) # 신청을 지우면 함께
|
|
|
|
def test_consult_reject_edit_and_resubmit(self):
|
|
"""협의자 한 명이 반려 → 신청 반려, 고쳐서 다시 제출하면 협의가 처음부터, 협의자 없이 내면 바로 제출."""
|
|
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
|
|
rid = self._consult_req(owner)["id"]
|
|
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
|
|
with self.assertRaisesRegex(ValueError, "사유"):
|
|
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False)
|
|
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="일정 겹침")
|
|
self.assertEqual((got["status"], got["reject_reason"], got["approver_email"], event), ("반려", "일정 겹침", "choi@test.local", "rejected"))
|
|
again = self.st.submit(request_id=rid, owner=owner)
|
|
self.assertEqual(again["status"], "협의중")
|
|
self.assertEqual({c["state"] for c in self.st.list_consults(request_id=rid)}, {"대기"})
|
|
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="x")
|
|
payload = {"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-05", "reason": "y"}
|
|
self.st.update_request(request_id=rid, owner=owner, payload=payload, consults=[])
|
|
self.assertEqual(self.st.list_consults(request_id=rid), [])
|
|
self.assertEqual(self.st.submit(request_id=rid, owner=owner)["status"], "제출")
|
|
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=False)
|
|
|
|
def test_consult_mail_log_events(self):
|
|
"""003 이 메일 기록 CHECK 를 넓혔는지 — 협의 메일도 기록된다."""
|
|
rid = uuid.uuid4().hex[:12]
|
|
for ev in ("consult_request", "consulted"):
|
|
self.st.add_mail_log(request_id=rid, event=ev, sender="a@test.local", via="smtp", recipients=["b@test.local"], subject="s", ok=True)
|
|
self.assertEqual([m["event"] for m in self.st.list_mail_log(request_id=rid)], ["consult_request", "consulted"])
|
|
|
|
def test_submit_approve_mail_log_end_to_end(self):
|
|
"""신청 → 제출 → 승인을 실제 DB 로, 메일은 가짜 SMTP — 기록이 상세 화면용 목록으로 나온다."""
|
|
from app.modules.vacation import notify
|
|
|
|
self.st.save_options(approvers=["lee@test.local"], notifiers=["hr@test.local"], by="admin@test.local")
|
|
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
|
|
req = self.st.create_request(owner=owner, owner_name="김철수", status="작성중",
|
|
payload={"vacation_type": "연차", "start_date": "2026-11-02", "end_date": "2026-11-03",
|
|
"start_half": "full", "end_half": "full", "reason": "가족 행사"})
|
|
sub = self.st.submit(request_id=req["id"], owner=owner)
|
|
done = self.st.approve(request_id=req["id"], approver_email="lee@test.local")
|
|
users = [{"email": "lee@test.local", "name": "이팀장", "modules": {"vacation": True}}]
|
|
with patch("app.mail.send_email", return_value=True) as smtp, patch("app.mail.mail_enabled", return_value=True):
|
|
r1 = notify.deliver(self.st, None, event="submitted", req=sub, actor={"email": owner, "name": "김철수"},
|
|
users=users, link="https://erp.test/vacation/" + req["id"])
|
|
r2 = notify.deliver(self.st, None, event="approved", req=done, actor={"email": "lee@test.local", "name": "이팀장"},
|
|
users=users, link="https://erp.test/vacation/" + req["id"])
|
|
self.assertTrue(r1["ok"] and r2["ok"])
|
|
self.assertEqual(smtp.call_args_list[1].kwargs["to"], ["lee@test.local", "hr@test.local", owner])
|
|
log = self.st.list_mail_log(request_id=req["id"])
|
|
self.assertEqual([(m["event"], m["via"], m["ok"]) for m in log], [("submitted", "smtp", True), ("approved", "smtp", True)])
|
|
self.assertEqual(log[0]["sender"], owner)
|
|
self.assertEqual(log[1]["recipients"], f"lee@test.local, hr@test.local, {owner}")
|
|
self.assertIn("[휴가 승인] 김철수 · 연차", log[1]["subject"])
|
|
self.st.hard_delete(request_id=req["id"], user_email=owner, is_admin=True)
|
|
self.st.save_options(approvers=[], notifiers=[], by="admin@test.local")
|
|
|
|
|
|
@unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정")
|
|
class VacationHolidayBalanceDBTests(unittest.TestCase):
|
|
"""2026-10-27 — 쉬는 날 = 국경일·대체공휴일 표, 연차 = 승인된 연차·반차만·해마다 나눠 셈, 잔여 연차 한꺼번에 저장."""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from app.modules.vacation.db import VacationDBStore
|
|
|
|
cls.st = VacationDBStore(DSN)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.st.close()
|
|
|
|
def test_holiday_map_is_national_table_only(self):
|
|
"""쉬는 날 = 국경일·대체공휴일 표만(공휴일 설정 화면 삭제 — vacation_holidays 에 남은 줄은 읽지 않음)."""
|
|
st = self.st
|
|
m = st.holiday_map(date_from="2027-10-01", date_to="2027-10-31")
|
|
self.assertEqual(m, {"2027-10-03": "개천절", "2027-10-04": "개천절 대체", "2027-10-09": "한글날", "2027-10-11": "한글날 대체"})
|
|
self.assertEqual(st.holiday_map(date_from="2026-07-17", date_to="2026-07-17"), {"2026-07-17": "제헌절"}) # 예전 seed 에 없던 날
|
|
with st._pool.connection() as conn: # noqa: SLF001 — 예전 설정 화면이 남긴 줄을 흉내
|
|
conn.execute("INSERT INTO vacation_holidays (holiday_date, name, kind, is_red) VALUES ('2027-10-08', '창립기념일', 'company', TRUE), "
|
|
"('2027-10-11', '한글날 대체', 'substitute', FALSE) ON CONFLICT (holiday_date) DO NOTHING")
|
|
try:
|
|
self.assertEqual(st.holiday_map(date_from="2027-10-01", date_to="2027-10-31"), m) # 그대로
|
|
self.assertEqual(st.red_holiday_set(date_from="2027-10-01", date_to="2027-10-31"), set(m))
|
|
finally:
|
|
with st._pool.connection() as conn: # noqa: SLF001
|
|
conn.execute("DELETE FROM vacation_holidays WHERE holiday_date IN ('2027-10-08', '2027-10-11')")
|
|
|
|
def _approved(self, owner, vtype, start, end, sh="full", eh="full"):
|
|
req = self.st.create_request(owner=owner, owner_name="테스트", status="제출",
|
|
payload={"vacation_type": vtype, "start_date": start, "end_date": end,
|
|
"start_half": sh, "end_half": eh, "reason": ""})
|
|
self.st.approve(request_id=req["id"], approver_email="lee@test.local")
|
|
return req
|
|
|
|
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"
|
|
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:
|
|
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(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(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 LeaveRulesTests(unittest.TestCase):
|
|
"""근로기준법 제60조 — 입사일 기준, 연차마다 쓸 수 있는 기한(2026-10-27, 12/31 소멸 없음, DB 없음)."""
|
|
|
|
def test_grants_periods_and_usage_units(self):
|
|
from datetime import date as D
|
|
|
|
from app.modules.vacation.store import add_months, compute_days, leave_grants, leave_period, usage_units
|
|
|
|
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)."""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from app.modules.vacation.db import VacationDBStore
|
|
|
|
cls.st = VacationDBStore(DSN)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.st.close()
|
|
|
|
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(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], "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(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, as_of=on)["available"], 0.0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|