feat: 당일 크롤 미발견 공고 즉시 비활성화 (mark-and-sweep)

기존 문제: 마감된 공고가 7일 동안 계속 노출됨
- deactivate_expired_jobs()의 staleness 기준이 7일이라 즉시 반영 안 됨

변경 내용:

[db/connection.py]
- deactivate_unseen_jobs(conn, source_site, crawl_start_iso) 추가
- crawl_start_iso 이전에 updated_at이 머문 공고 = 오늘 크롤에서 미발견
- 해당 source_site 공고만 한정하여 즉시 is_active=0 처리
- deactivate_expired_jobs() 단순화
- 7일 staleness 기준 제거 (deactivate_unseen_jobs로 대체)
- deadline_date 초과 공고만 처리하는 보조 수단으로 축소
- 반환 타입: dict → int

[crawler/run.py]
- run_crawler() 시작 시 crawl_start(UTC) 기록
- upsert 완료 후 deactivate_unseen_jobs() 호출 → 소스별 당일 기준 즉시 비활성화
- main()에서 URL 링크 검증 제거 (당일 비활성화가 대체)
- 로그에 "당일 미발견 비활성화 N건" 출력

[tests/test_db.py]
- TestDeactivateUnseenJobs 5케이스 추가 (95/95 PASS)
- TestDeactivateExpiredJobs staleness 테스트 제거, int 반환 기준으로 업데이트

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

crawler/run.py

@@ -8,6 +8,7 @@ import argparse
 import logging
 import sys
 import time
+from datetime import datetime, timezone
 from pathlib import Path
 
 import requests as _requests
@@ -15,7 +16,10 @@ import requests as _requests
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from crawler import WantedCrawler, SaraminCrawler, JobKoreaCrawler
-from db.connection import init_db, get_conn, upsert_job, insert_skills, deactivate_expired_jobs
+from db.connection import (
+    init_db, get_conn, upsert_job, insert_skills,
+    deactivate_unseen_jobs, deactivate_expired_jobs,
+)
 
 logging.basicConfig(
     level=logging.INFO,
@@ -104,9 +108,12 @@ def run_crawler(source: str, max_pages: int) -> dict:
     }
     CrawlerClass = crawlers[source]
     crawler = CrawlerClass()
+
+    # 크롤 시작 시각 기록 (UTC) — 이 시각보다 updated_at이 이전인 공고 = 오늘 미발견
+    crawl_start = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
     jobs = crawler.crawl_all_categories(max_pages=max_pages)
 
-    stats = {"found": len(jobs), "inserted": 0, "updated": 0, "errors": 0}
+    stats = {"found": len(jobs), "inserted": 0, "updated": 0, "deactivated": 0, "errors": 0}
 
     with get_conn() as conn:
         log_id = conn.execute(
@@ -124,6 +131,9 @@ def run_crawler(source: str, max_pages: int) -> dict:
                     logger.error(f"DB 저장 실패: {e} — {job.source_id}")
                     stats["errors"] += 1
 
+            # 오늘 크롤에서 발견 안 된 공고 즉시 비활성화
+            stats["deactivated"] = deactivate_unseen_jobs(conn, source, crawl_start)
+
             conn.execute(
                 """
                 UPDATE crawl_logs
@@ -171,23 +181,15 @@ def main():
             f"발견 {stats['found']}건 / "
             f"신규 {stats.get('inserted', 0)}건 / "
             f"업데이트 {stats.get('updated', 0)}건 / "
+            f"당일 미발견 비활성화 {stats.get('deactivated', 0)}건 / "
             f"오류 {stats['errors']}건 ==="
         )
 
-    # 전체 크롤 완료 후 만료 공고 비활성화 + URL 링크 검증
+    # 마감일 초과 공고 비활성화 (deadline_date 명시된 공고 한정)
     with get_conn() as conn:
-        expired = deactivate_expired_jobs(conn)
-        logger.info(
-            f"만료 공고 비활성화 — "
-            f"마감일 초과: {expired['by_deadline']}건, "
-            f"7일 미발견: {expired['by_staleness']}건"
-        )
-        link_stats = validate_job_links(conn, max_checks=30, delay=1.5)
-    logger.info(
-        f"URL 링크 검증 — "
-        f"검사: {link_stats['checked']}건, "
-        f"링크 만료 비활성화: {link_stats['deactivated']}건"
-    )
+        n_deadline = deactivate_expired_jobs(conn)
+    if n_deadline:
+        logger.info(f"마감일 초과 비활성화: {n_deadline}건")
 
 
 if __name__ == "__main__":

db/connection.py

@@ -137,37 +137,51 @@ def insert_skills(conn: sqlite3.Connection, job_id: int, skills: list[str]) -> N
     )
 
 
-def deactivate_expired_jobs(conn: sqlite3.Connection) -> dict[str, int]:
-    """만료 공고를 is_active=0으로 표시.
-
-    두 가지 기준으로 비활성화:
-    1. deadline_date 기준: 마감일이 오늘 이전인 공고 (명시적 만료)
-    2. 비활성 staleness 기준: 마감일 정보가 없고 7일 이상 크롤러에서 다시 발견되지 않은 공고
-       - upsert_job()은 공고를 발견할 때마다 updated_at을 갱신하므로,
-         updated_at이 오래된 공고 = 사이트에서 사라진 것으로 추정
-
-    반환: {"by_deadline": N, "by_staleness": M}  (비활성화된 각 건수)
+def deactivate_unseen_jobs(
+    conn: sqlite3.Connection,
+    source_site: str,
+    crawl_start_iso: str,
+) -> int:
+    """해당 소스에서 이번 크롤에 발견되지 않은 공고를 즉시 비활성화.
+
+    upsert_job()은 공고를 발견할 때마다 updated_at을 현재 시각으로 갱신함.
+    따라서 crawl_start_iso 이전에 updated_at이 머물러 있는 공고
+    = 이번 크롤에서 한 번도 발견되지 않은 공고 = 사이트에서 내려진 것으로 판단.
+
+    Args:
+        source_site:    'wanted' | 'saramin' | 'jobkorea'
+        crawl_start_iso: 크롤 시작 시각 (UTC, 'YYYY-MM-DD HH:MM:SS')
+
+    반환: 비활성화된 공고 수
     """
-    # 1) 마감일 지난 공고
-    cur_deadline = conn.execute(
+    cur = conn.execute(
         """
         UPDATE jobs
         SET is_active = 0, updated_at = CURRENT_TIMESTAMP
-        WHERE is_active = 1
-          AND deadline_date IS NOT NULL
-          AND deadline_date < date('now')
-        """
+        WHERE source_site = ?
+          AND is_active   = 1
+          AND updated_at  < ?
+        """,
+        (source_site, crawl_start_iso),
     )
-    # 2) 마감일 없이 7일 이상 미발견 공고
-    cur_stale = conn.execute(
+    return cur.rowcount
+
+
+def deactivate_expired_jobs(conn: sqlite3.Connection) -> int:
+    """마감일이 지난 공고를 is_active=0으로 표시 (deadline_date 기준).
+
+    당일 크롤 미발견 공고는 run_crawler() 내 deactivate_unseen_jobs()로 처리.
+    이 함수는 deadline_date가 명시된 공고의 마감일 초과만 처리하는 보조 수단.
+
+    반환: 비활성화된 공고 수
+    """
+    cur = conn.execute(
         """
         UPDATE jobs
         SET is_active = 0, updated_at = CURRENT_TIMESTAMP
         WHERE is_active = 1
-          AND updated_at < datetime('now', '-7 days')
+          AND deadline_date IS NOT NULL
+          AND deadline_date < date('now')
         """
     )
-    return {
-        "by_deadline": cur_deadline.rowcount,
-        "by_staleness": cur_stale.rowcount,
-    }
+    return cur.rowcount

tests/test_db.py

@@ -11,7 +11,7 @@ from unittest.mock import MagicMock
 from db.connection import (
     init_db, get_conn, upsert_job, insert_skills,
     _is_cross_site_duplicate, _titles_are_duplicate,
-    deactivate_expired_jobs,
+    deactivate_unseen_jobs, deactivate_expired_jobs,
 )
 from crawler.run import validate_job_links
 
@@ -295,70 +295,102 @@ class TestValidateJobLinks:
         assert "deactivated" in result
 
 
-# ── deactivate_expired_jobs ───────────────────────────────────────
+# ── deactivate_unseen_jobs ────────────────────────────────────────
 
-class TestDeactivateExpiredJobs:
-    def test_deactivates_past_deadline(self):
-        """마감일이 지난 공고는 비활성화."""
+class TestDeactivateUnseenJobs:
+    def test_deactivates_job_not_seen_in_crawl(self):
+        """크롤 시작 전 updated_at → 오늘 미발견 공고 비활성화."""
         conn = _make_in_memory_conn()
-        upsert_job(conn, _sample_job(source_id="1", deadline_date="2020-01-01"))
+        upsert_job(conn, _sample_job(source_site="wanted", source_id="1"))
+        conn.execute("UPDATE jobs SET updated_at='2020-01-01 00:00:00' WHERE source_id='1'")
         conn.commit()
-        result = deactivate_expired_jobs(conn)
+
+        count = deactivate_unseen_jobs(conn, "wanted", "2025-01-01 09:00:00")
         conn.commit()
-        assert result["by_deadline"] >= 1
+
+        assert count == 1
         row = conn.execute("SELECT is_active FROM jobs WHERE source_id='1'").fetchone()
         assert row["is_active"] == 0
 
-    def test_keeps_future_deadline_active(self):
-        """마감일이 아직 남은 공고는 유지."""
+    def test_keeps_job_seen_in_crawl(self):
+        """크롤 시작 이후 updated_at → 활성 유지."""
         conn = _make_in_memory_conn()
-        upsert_job(conn, _sample_job(source_id="2", deadline_date="2099-12-31"))
+        upsert_job(conn, _sample_job(source_site="wanted", source_id="2"))
         conn.commit()
-        deactivate_expired_jobs(conn)
+
+        # crawl_start를 과거로 → 현재 updated_at(≈now)이 이후임
+        count = deactivate_unseen_jobs(conn, "wanted", "2020-01-01 00:00:00")
         conn.commit()
+
+        assert count == 0
         row = conn.execute("SELECT is_active FROM jobs WHERE source_id='2'").fetchone()
         assert row["is_active"] == 1
 
-    def test_deactivates_stale_no_deadline(self):
-        """마감일 없이 7일 이상 발견되지 않은 공고는 비활성화."""
+    def test_only_affects_matching_source(self):
+        """다른 source_site 공고는 영향 없음."""
         conn = _make_in_memory_conn()
-        upsert_job(conn, _sample_job(source_id="3", deadline_date=None))
+        upsert_job(conn, _sample_job(source_site="wanted",  source_id="3"))
+        upsert_job(conn, _sample_job(source_site="saramin", source_id="4"))
+        conn.execute("UPDATE jobs SET updated_at='2020-01-01 00:00:00'")
         conn.commit()
-        # updated_at을 8일 전으로 강제 설정
-        conn.execute(
-            "UPDATE jobs SET updated_at = datetime('now', '-8 days') WHERE source_id='3'"
-        )
+
+        count = deactivate_unseen_jobs(conn, "wanted", "2025-01-01 09:00:00")
         conn.commit()
-        result = deactivate_expired_jobs(conn)
+
+        assert count == 1
+        assert conn.execute("SELECT is_active FROM jobs WHERE source_id='3'").fetchone()["is_active"] == 0
+        assert conn.execute("SELECT is_active FROM jobs WHERE source_id='4'").fetchone()["is_active"] == 1
+
+    def test_already_inactive_not_counted(self):
+        """이미 비활성인 공고는 카운트 제외."""
+        conn = _make_in_memory_conn()
+        upsert_job(conn, _sample_job(source_site="wanted", source_id="5"))
+        conn.execute("UPDATE jobs SET is_active=0, updated_at='2020-01-01' WHERE source_id='5'")
+        conn.commit()
+
+        count = deactivate_unseen_jobs(conn, "wanted", "2025-01-01 09:00:00")
+        assert count == 0
+
+    def test_returns_int(self):
+        conn = _make_in_memory_conn()
+        result = deactivate_unseen_jobs(conn, "wanted", "2025-01-01 09:00:00")
+        assert isinstance(result, int)
+
+
+# ── deactivate_expired_jobs ───────────────────────────────────────
+
+class TestDeactivateExpiredJobs:
+    def test_deactivates_past_deadline(self):
+        """마감일이 지난 공고는 비활성화."""
+        conn = _make_in_memory_conn()
+        upsert_job(conn, _sample_job(source_id="10", deadline_date="2020-01-01"))
         conn.commit()
-        assert result["by_staleness"] >= 1
-        row = conn.execute("SELECT is_active FROM jobs WHERE source_id='3'").fetchone()
+        count = deactivate_expired_jobs(conn)
+        conn.commit()
+        assert count >= 1
+        row = conn.execute("SELECT is_active FROM jobs WHERE source_id='10'").fetchone()
         assert row["is_active"] == 0
 
-    def test_keeps_recent_no_deadline_active(self):
-        """마감일 없어도 최근(1일)에 발견된 공고는 유지."""
+    def test_keeps_future_deadline_active(self):
+        """마감일이 아직 남은 공고는 유지."""
         conn = _make_in_memory_conn()
-        upsert_job(conn, _sample_job(source_id="4", deadline_date=None))
+        upsert_job(conn, _sample_job(source_id="11", deadline_date="2099-12-31"))
         conn.commit()
         deactivate_expired_jobs(conn)
         conn.commit()
-        row = conn.execute("SELECT is_active FROM jobs WHERE source_id='4'").fetchone()
+        row = conn.execute("SELECT is_active FROM jobs WHERE source_id='11'").fetchone()
         assert row["is_active"] == 1
 
-    def test_already_inactive_not_double_counted(self):
-        """이미 비활성인 공고는 카운트에 포함되지 않음 (rowcount=0)."""
+    def test_already_inactive_not_counted(self):
+        """이미 비활성인 공고는 카운트에 포함되지 않음."""
         conn = _make_in_memory_conn()
-        upsert_job(conn, _sample_job(source_id="5", deadline_date="2020-01-01"))
-        conn.execute("UPDATE jobs SET is_active=0 WHERE source_id='5'")
+        upsert_job(conn, _sample_job(source_id="12", deadline_date="2020-01-01"))
+        conn.execute("UPDATE jobs SET is_active=0 WHERE source_id='12'")
         conn.commit()
-        result = deactivate_expired_jobs(conn)
-        # 이미 0인 행은 UPDATE 영향 없음
-        assert result["by_deadline"] == 0
-        assert result["by_staleness"] == 0
+        count = deactivate_expired_jobs(conn)
+        assert count == 0
 
-    def test_returns_correct_counts(self):
-        """반환 딕셔너리에 by_deadline / by_staleness 키가 있음."""
+    def test_returns_int(self):
         conn = _make_in_memory_conn()
         result = deactivate_expired_jobs(conn)
-        assert "by_deadline" in result
-        assert "by_staleness" in result
+        assert isinstance(result, int)