pro-sejong-auth 1.2.16__tar.gz

pro_sejong_auth-1.2.16/.gitignore

@@ -0,0 +1,86 @@
+/.idea
+/.claude/settings.local.json
+/.report
+
+# Gradle
+.gradle/
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!gradle/wrapper/gradle-wrapper.properties
+gradle.properties
+
+# Compiled Files
+*.class
+*.jar
+!gradle/wrapper/gradle-wrapper.jar
+
+# IDE - IntelliJ IDEA
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+# IDE - Eclipse
+.classpath
+.project
+.settings/
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+# IDE - VS Code
+.vscode/
+
+# IDE - NetBeans
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nbgradle/
+
+# OS Files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+.AppleDouble
+.LSOverride
+
+# Logs
+*.log
+*.log.*
+
+# Local Configuration
+*.local
+
+# Test Reports
+.report/
+
+# Test Configuration (민감 정보 포함)
+**/src/test/resources/application-dev.yml
+
+# Python (기존 항목 유지)
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Python
+python/.venv/
+python/dist/
+.pytest_cache/
+*.egg-info/
+
+# Node
+node/node_modules/
+node/dist/
+*.tgz
+
+# SDD workspace
+.superpowers/
+node/src/version.ts

pro_sejong_auth-1.2.16/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Suh Saechan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pro_sejong_auth-1.2.16/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.5
+Name: pro-sejong-auth
+Version: 1.2.16
+Summary: Sejong University login API for Python: verify students with portal SSO in one line (세종대 로그인 API)
+Project-URL: Homepage, https://cassiiopeia.github.io/pro-sejong-auth/
+Project-URL: Source, https://github.com/Cassiiopeia/pro-sejong-auth
+Project-URL: Issues, https://github.com/Cassiiopeia/pro-sejong-auth/issues
+Author: Suh Saechan
+License-Expression: MIT
+License-File: LICENSE
+Keywords: authentication,sejong,sejong-university,sso,student-verification,세종대
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: Korean
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# pro-sejong-auth (Python)
+
+**Sejong University login API for Python** · 세종대 로그인 API
+
+Verify a Sejong University student with a student ID and password through the portal SSO, and get their major, year, classic-reading certification and contact info. No dependencies beyond the standard library.
+
+```bash
+pip install pro-sejong-auth
+```
+
+```python
+from sejong_auth import authenticate, SejongAuthError, ErrorCode
+
+try:
+    result = authenticate("21011234", "password")
+    print(result.name, result.major, result.grade)
+except SejongAuthError as error:
+    if error.code == ErrorCode.AUTHENTICATION_FAILED:
+        print("Wrong student ID or password")
+```
+
+| Function | Returns |
+|---|---|
+| `authenticate(id, pw)` | student info + classic reading + contact (contact is `None` if that lookup fails) |
+| `authenticate_dhc(id, pw, include_raw=False)` | student info + classic reading |
+| `authenticate_sis(id, pw, include_raw=False)` | student info + email, phone, English name |
+
+Settings: `SejongAuthClient(timeout_seconds=10, max_retry=3, ssl_verification=True)`.
+
+Requires Python 3.9+. Not an official Sejong University product.
+
+Docs, live demo and Java / Node versions: https://cassiiopeia.github.io/pro-sejong-auth/

pro_sejong_auth-1.2.16/README.md

@@ -0,0 +1,32 @@
+# pro-sejong-auth (Python)
+
+**Sejong University login API for Python** · 세종대 로그인 API
+
+Verify a Sejong University student with a student ID and password through the portal SSO, and get their major, year, classic-reading certification and contact info. No dependencies beyond the standard library.
+
+```bash
+pip install pro-sejong-auth
+```
+
+```python
+from sejong_auth import authenticate, SejongAuthError, ErrorCode
+
+try:
+    result = authenticate("21011234", "password")
+    print(result.name, result.major, result.grade)
+except SejongAuthError as error:
+    if error.code == ErrorCode.AUTHENTICATION_FAILED:
+        print("Wrong student ID or password")
+```
+
+| Function | Returns |
+|---|---|
+| `authenticate(id, pw)` | student info + classic reading + contact (contact is `None` if that lookup fails) |
+| `authenticate_dhc(id, pw, include_raw=False)` | student info + classic reading |
+| `authenticate_sis(id, pw, include_raw=False)` | student info + email, phone, English name |
+
+Settings: `SejongAuthClient(timeout_seconds=10, max_retry=3, ssl_verification=True)`.
+
+Requires Python 3.9+. Not an official Sejong University product.
+
+Docs, live demo and Java / Node versions: https://cassiiopeia.github.io/pro-sejong-auth/

pro_sejong_auth-1.2.16/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pro-sejong-auth"
+version = "1.2.16"
+description = "Sejong University login API for Python: verify students with portal SSO in one line (세종대 로그인 API)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Suh Saechan" }]
+keywords = ["sejong", "sejong-university", "세종대", "authentication", "sso", "student-verification"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Developers",
+  "Natural Language :: Korean",
+  "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://cassiiopeia.github.io/pro-sejong-auth/"
+Source = "https://github.com/Cassiiopeia/pro-sejong-auth"
+Issues = "https://github.com/Cassiiopeia/pro-sejong-auth/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sejong_auth"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "tests"]

pro_sejong_auth-1.2.16/src/sejong_auth/__init__.py

@@ -0,0 +1,52 @@
+"""세종대 로그인 API: 학번·비밀번호로 세종대학교 포털(SSO) 인증
+
+    from sejong_auth import authenticate
+    result = authenticate("21011234", "password")
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # 버전 단일 원본: pyproject.toml (projectops 가 version.yml 과 함께 갱신)
+    __version__ = version("pro-sejong-auth")
+except PackageNotFoundError:  # 설치 없이 소스로 실행 (테스트)
+    __version__ = "0.0.0-dev"
+
+from .client import SejongAuthClient  # noqa: E402
+from .errors import ErrorCode, SejongAuthError  # noqa: E402
+from .models import (  # noqa: E402
+    ClassicCertification,
+    ClassicContestRecord,
+    ClassicExamRecord,
+    ClassicSubjectRecord,
+    SejongAuthResult,
+    SejongClassicReading,
+    SejongDhcAuthResult,
+    SejongSisAuthResult,
+)
+
+_default_client = SejongAuthClient()
+
+
+def authenticate(student_id: str, password: str) -> SejongAuthResult:
+    """통합 인증 (기본 설정: 10초, 재시도 3회, 인증서 검증)"""
+    return _default_client.authenticate(student_id, password)
+
+
+def authenticate_dhc(student_id: str, password: str, include_raw: bool = False) -> SejongDhcAuthResult:
+    """DHC 인증: 학생 정보 + 고전독서"""
+    return _default_client.authenticate_dhc(student_id, password, include_raw=include_raw)
+
+
+def authenticate_sis(student_id: str, password: str, include_raw: bool = False) -> SejongSisAuthResult:
+    """SIS 인증: 학생 정보 + 연락처"""
+    return _default_client.authenticate_sis(student_id, password, include_raw=include_raw)
+
+
+__all__ = [
+    "authenticate", "authenticate_dhc", "authenticate_sis", "SejongAuthClient",
+    "SejongAuthError", "ErrorCode",
+    "SejongAuthResult", "SejongDhcAuthResult", "SejongSisAuthResult", "SejongClassicReading",
+    "ClassicCertification", "ClassicExamRecord", "ClassicSubjectRecord", "ClassicContestRecord",
+    "__version__",
+]

pro_sejong_auth-1.2.16/src/sejong_auth/client.py

@@ -0,0 +1,171 @@
+"""세종대 포털 인증 클라이언트: 입력 검증 > 포털 로그인(재시도) > SSO > 데이터 조회 > 파싱 (흐름: spec/PORTAL_FLOW.md)"""
+
+import base64
+import json
+import ssl
+import urllib.parse
+from datetime import datetime
+from typing import Callable, Optional
+
+from . import __version__
+from .errors import ErrorCode, SejongAuthError
+from .models import SejongAuthResult, SejongDhcAuthResult, SejongSisAuthResult
+from .parsers import ensure_sis_logged_in, parse_classic_reading, parse_sis_user_info, parse_student_info
+from .transport import HttpResponse, UrllibSession, create_ssl_context
+
+PORTAL_LOGIN_URL = "https://portal.sejong.ac.kr/jsp/login/login_action.jsp"
+PORTAL_REFERER = "https://portal.sejong.ac.kr"
+# 포털이 요구하는 초기 쿠키 (없으면 로그인 폼 거부)
+PORTAL_DEFAULT_COOKIE = "chknos=false"
+
+# 로그인 후 SSO 대상 (rtUrl)
+CLASSIC_RETURN_URL = "classic.sejong.ac.kr"
+SIS_RETURN_URL = "sjpt.sejong.ac.kr/main/view/Login/doSsoLogin.do?p="
+
+CLASSIC_SSO_URL = "https://classic.sejong.ac.kr/_custom/sejong/sso/sso-return.jsp?returnUrl=https://classic.sejong.ac.kr/classic/index.do"
+CLASSIC_STATUS_URL = "https://classic.sejong.ac.kr/classic/reading/status.do"
+SIS_SSO_URL = "https://sjpt.sejong.ac.kr/main/view/Login/doSsoLogin.do?p="
+SIS_USER_INFO_URL = "https://sjpt.sejong.ac.kr/main/sys/UserInfo/initUserInfo.do"
+SIS_ORIGIN = "https://sjpt.sejong.ac.kr"
+# 브라우저 초기 호출과 같은 빈 addParam (JSON > URL 폼 인코딩 > Base64)
+SIS_EMPTY_ADD_PARAM = base64.b64encode(
+    urllib.parse.quote_plus('{"_runIntgUsrNo":"","_runPgLoginDt":"","_runningSejong":""}').encode("utf-8")
+).decode("ascii")
+
+USER_AGENT = f"pro-sejong-auth-python/{__version__}"
+HTTP_UNAUTHORIZED = 401
+
+
+class SejongAuthClient:
+    """세종대 포털 인증 (설정: 제한 시간 초, 로그인 재시도 횟수, 인증서 검증)"""
+
+    def __init__(self, timeout_seconds: float = 10, max_retry: int = 3, ssl_verification: bool = True,
+                 _session_factory: Optional[Callable[[], object]] = None):
+        self.timeout_seconds = timeout_seconds
+        self.max_retry = max_retry
+        self.ssl_verification = ssl_verification
+        self._session_factory = _session_factory or self._create_session
+
+    def authenticate(self, student_id: str, password: str) -> SejongAuthResult:
+        """통합 인증: DHC 학생 정보·고전독서 + SIS 연락처 (SIS 실패는 무시하고 None)"""
+        self._validate_credentials(student_id, password)
+        dhc_result = self._fetch_dhc(student_id, password, should_include_raw_html=False)
+
+        email = phone_number = english_name = None
+        try:
+            sis_user_info = parse_sis_user_info(self._fetch_sis_json(student_id, password))
+            email, phone_number, english_name = sis_user_info.email, sis_user_info.phone_number, sis_user_info.english_name
+        except Exception:  # SIS 는 연락처 보조 조회 > 어떤 실패든 통합 결과를 막지 않음 (Java 와 동일)
+            pass
+
+        return SejongAuthResult(
+            success=True, student_id=dhc_result.student_id, name=dhc_result.name, major=dhc_result.major,
+            grade=dhc_result.grade, status=dhc_result.status, classic_reading=dhc_result.classic_reading,
+            email=email, phone_number=phone_number, english_name=english_name, authenticated_at=datetime.now(),
+        )
+
+    def authenticate_dhc(self, student_id: str, password: str, include_raw: bool = False) -> SejongDhcAuthResult:
+        """DHC 인증: 학생 정보 + 고전독서 (include_raw=True 면 원본 HTML 포함)"""
+        self._validate_credentials(student_id, password)
+        return self._fetch_dhc(student_id, password, should_include_raw_html=include_raw)
+
+    def authenticate_sis(self, student_id: str, password: str, include_raw: bool = False) -> SejongSisAuthResult:
+        """SIS 인증: 학생 정보 + 연락처 (학년·상태 빈 문자열, include_raw=True 면 원본 JSON 포함)"""
+        self._validate_credentials(student_id, password)
+        json_text = self._fetch_sis_json(student_id, password)
+        user_info = parse_sis_user_info(json_text)
+        return SejongSisAuthResult(
+            success=True, student_id=user_info.student_id, name=user_info.name, major=user_info.major,
+            grade="", status="", email=user_info.email, phone_number=user_info.phone_number,
+            english_name=user_info.english_name, authenticated_at=datetime.now(),
+            raw_json=json_text if include_raw else None,
+        )
+
+    def _fetch_dhc(self, student_id: str, password: str, should_include_raw_html: bool) -> SejongDhcAuthResult:
+        """포털 로그인 > classic SSO > 고전독서 페이지 > 학생 정보·고전독서 파싱"""
+        session = self._session_factory()
+        self._login(session, student_id, password, CLASSIC_RETURN_URL)
+        self._expect_session_step(self._call(session, "GET", CLASSIC_SSO_URL), "SSO redirect failed")
+        html = self._expect_data(self._call(session, "GET", CLASSIC_STATUS_URL), "Classic reading page request failed")
+        student_info = parse_student_info(html)
+        return SejongDhcAuthResult(
+            success=True, student_id=student_info.student_id, name=student_info.name, major=student_info.major,
+            grade=student_info.grade, status=student_info.status, classic_reading=parse_classic_reading(html),
+            authenticated_at=datetime.now(), raw_html=html if should_include_raw_html else None,
+        )
+
+    def _fetch_sis_json(self, student_id: str, password: str) -> str:
+        """포털 로그인 > sjpt SSO > initUserInfo JSON"""
+        session = self._session_factory()
+        self._login(session, student_id, password, SIS_RETURN_URL)
+        self._expect_session_step(
+            self._call(session, "GET", SIS_SSO_URL, headers={"Referer": PORTAL_REFERER}), "SIS SSO page request failed")
+        response = self._call(session, "POST", f"{SIS_USER_INFO_URL}?addParam={SIS_EMPTY_ADD_PARAM}", data=b"{}", headers={
+            "Accept": "application/json",
+            "Content-Type": "application/json; charset=UTF-8",
+            "Referer": SIS_SSO_URL,
+            "Origin": SIS_ORIGIN,
+        })
+        json_text = self._expect_data(response, "initUserInfo API request failed")
+        # 틀린 비밀번호는 401 이 아니라 200 + _SUBMIT_ERROR_(LOGOUT)
+        ensure_sis_logged_in(json_text)
+        return json_text
+
+    def _login(self, session, student_id: str, password: str, return_url: str) -> None:
+        """포털 로그인 (실패 응답·시간 초과 시 max_retry 회까지, 성공 여부는 이후 401 로 판별)"""
+        form = urllib.parse.urlencode({"mainLogin": "N", "rtUrl": return_url, "id": student_id, "password": password})
+        headers = {"Content-Type": "application/x-www-form-urlencoded", "Referer": PORTAL_REFERER, "Cookie": PORTAL_DEFAULT_COOKIE}
+        for attempt in range(1, self.max_retry + 1):
+            try:
+                if self._call_raw(session, "POST", PORTAL_LOGIN_URL, data=form.encode("utf-8"), headers=headers).is_successful:
+                    return
+            except TimeoutError as error:
+                if attempt == self.max_retry:
+                    raise SejongAuthError(ErrorCode.CONNECTION_TIMEOUT) from error
+        raise SejongAuthError(ErrorCode.CONNECTION_FAILED, f"Max retry count exceeded : {self.max_retry}")
+
+    def _call(self, session, method: str, url: str, **kwargs) -> HttpResponse:
+        """로그인 외 요청 (시간 초과·네트워크 오류 > CONNECTION_FAILED)"""
+        try:
+            return self._call_raw(session, method, url, **kwargs)
+        except TimeoutError as error:
+            raise SejongAuthError(ErrorCode.CONNECTION_FAILED) from error
+
+    @staticmethod
+    def _call_raw(session, method: str, url: str, **kwargs) -> HttpResponse:
+        try:
+            return session.request(method, url, **kwargs)
+        except (TimeoutError, SejongAuthError):
+            raise
+        except ssl.SSLError as error:
+            raise SejongAuthError(ErrorCode.CONNECTION_FAILED, "TLS handshake with the portal failed") from error
+        except OSError as error:
+            raise SejongAuthError(ErrorCode.CONNECTION_FAILED) from error
+
+    @staticmethod
+    def _expect_session_step(response: HttpResponse, failure_message: str) -> None:
+        if not response.is_successful:
+            raise SejongAuthError(ErrorCode.SESSION_ERROR, f"{failure_message} : {response.status}")
+
+    @staticmethod
+    def _expect_data(response: HttpResponse, failure_message: str) -> str:
+        """데이터 응답 판정: 401 > AUTHENTICATION_FAILED, 그 외 200 아님·빈 본문 > DATA_FETCH_FAILED"""
+        if response.status == HTTP_UNAUTHORIZED:
+            raise SejongAuthError(ErrorCode.AUTHENTICATION_FAILED)
+        if response.status != 200 or not response.body:
+            raise SejongAuthError(ErrorCode.DATA_FETCH_FAILED, f"{failure_message} : {response.status}")
+        return response.text()
+
+    @staticmethod
+    def _validate_credentials(student_id: Optional[str], password: Optional[str]) -> None:
+        if not student_id or not str(student_id).strip():
+            raise SejongAuthError(ErrorCode.INVALID_INPUT, "Student ID is empty")
+        if not password or not str(password).strip():
+            raise SejongAuthError(ErrorCode.INVALID_INPUT, "Password is empty")
+
+    def _create_session(self) -> UrllibSession:
+        try:
+            ssl_context = create_ssl_context(self.ssl_verification)
+        except ssl.SSLError as error:
+            raise SejongAuthError(ErrorCode.SSL_CONFIGURATION_ERROR) from error
+        return UrllibSession(ssl_context, self.timeout_seconds, USER_AGENT)

pro_sejong_auth-1.2.16/src/sejong_auth/errors.py

@@ -0,0 +1,38 @@
+"""에러 코드·예외: Java SejongAuthErrorCode 와 같은 이름 (spec/RESULT_SCHEMA.md)"""
+
+from enum import Enum
+
+
+class ErrorCode(str, Enum):
+    """인증 실패 사유 코드 (값 = Java enum 이름)"""
+
+    INVALID_INPUT = "INVALID_INPUT"
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED"
+    CONNECTION_FAILED = "CONNECTION_FAILED"
+    CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT"
+    SESSION_ERROR = "SESSION_ERROR"
+    DATA_FETCH_FAILED = "DATA_FETCH_FAILED"
+    PARSE_ERROR = "PARSE_ERROR"
+    SSL_CONFIGURATION_ERROR = "SSL_CONFIGURATION_ERROR"
+
+
+# 코드별 기본 메시지 (Java 메시지와 같은 영어 문구)
+DEFAULT_MESSAGE_BY_CODE = {
+    ErrorCode.INVALID_INPUT: "Invalid input.",
+    ErrorCode.AUTHENTICATION_FAILED: "Sejong University portal authentication failed. Check the student ID and password.",
+    ErrorCode.CONNECTION_FAILED: "Cannot connect to the Sejong University portal.",
+    ErrorCode.CONNECTION_TIMEOUT: "Connection to the Sejong University portal timed out.",
+    ErrorCode.SESSION_ERROR: "An error occurred while handling the portal session.",
+    ErrorCode.DATA_FETCH_FAILED: "Failed to fetch student information.",
+    ErrorCode.PARSE_ERROR: "Failed to parse student information.",
+    ErrorCode.SSL_CONFIGURATION_ERROR: "Failed to configure SSL.",
+}
+
+
+class SejongAuthError(Exception):
+    """세종 인증 실패 (code 로 분기, 메시지에 비밀번호·개인정보 없음)"""
+
+    def __init__(self, code: ErrorCode, message: str = ""):
+        self.code = code
+        self.message = message or DEFAULT_MESSAGE_BY_CODE[code]
+        super().__init__(f"{code.value}: {self.message}")

pro_sejong_auth-1.2.16/src/sejong_auth/models.py

@@ -0,0 +1,131 @@
+"""결과 모델: Java 결과 클래스와 같은 필드 (snake_case, spec/RESULT_SCHEMA.md)"""
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from typing import List, Optional
+
+
+@dataclass(frozen=True)
+class ClassicCertification:
+    area: str
+    required_count: str
+    certified_count: str
+
+
+@dataclass(frozen=True)
+class ClassicExamRecord:
+    semester: str
+    area: str
+    book_title: str
+    exam_date: str
+    score: str
+    pass_status: str
+
+
+@dataclass(frozen=True)
+class ClassicSubjectRecord:
+    semester: str
+    subject_name: str
+    area: str
+    book_title: str
+    completion: str
+
+
+@dataclass(frozen=True)
+class ClassicContestRecord:
+    semester: str
+    contest_name: str
+    area: str
+    book_title: str
+
+
+@dataclass(frozen=True)
+class SejongClassicReading:
+    """고전독서 인증 현황: 영역별 인증, 시험, 과목 대체, 대회, 교과연계"""
+
+    certifications: List[ClassicCertification] = field(default_factory=list)
+    exam_records: List[ClassicExamRecord] = field(default_factory=list)
+    subject_substitutions: List[ClassicSubjectRecord] = field(default_factory=list)
+    contest_records: List[ClassicContestRecord] = field(default_factory=list)
+    curriculum_records: List[ClassicSubjectRecord] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class SejongStudentInfo:
+    """DHC 사용자 정보 표: 학과, 학번, 이름, 학년, 학적 상태 (없으면 빈 문자열)"""
+
+    major: str
+    student_id: str
+    name: str
+    grade: str
+    status: str
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class SejongSisUserInfo:
+    """SIS initUserInfo: 학번, 이름, 학과, 이메일, 전화번호, 영문 이름"""
+
+    student_id: str
+    name: str
+    major: str
+    email: str
+    phone_number: str
+    english_name: str
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class SejongAuthResult:
+    """통합 인증 결과 (연락처는 SIS 실패 시 None)"""
+
+    success: bool
+    student_id: str
+    name: str
+    major: str
+    grade: str
+    status: str
+    classic_reading: SejongClassicReading
+    email: Optional[str]
+    phone_number: Optional[str]
+    english_name: Optional[str]
+    authenticated_at: datetime
+
+
+@dataclass(frozen=True)
+class SejongDhcAuthResult:
+    """DHC 인증 결과 (raw_html 은 include_raw=True 일 때만)"""
+
+    success: bool
+    student_id: str
+    name: str
+    major: str
+    grade: str
+    status: str
+    classic_reading: SejongClassicReading
+    authenticated_at: datetime
+    raw_html: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class SejongSisAuthResult:
+    """SIS 인증 결과 (학년·상태는 SIS 미제공 > 빈 문자열, raw_json 은 include_raw=True 일 때만)"""
+
+    success: bool
+    student_id: str
+    name: str
+    major: str
+    grade: str
+    status: str
+    email: str
+    phone_number: str
+    english_name: str
+    authenticated_at: datetime
+    raw_json: Optional[str] = None

pro_sejong_auth-1.2.16/src/sejong_auth/parsers.py

@@ -0,0 +1,227 @@
+"""포털 응답 파싱: DHC 고전독서 페이지 HTML, SIS initUserInfo JSON (규칙: spec/PORTAL_FLOW.md)"""
+
+import json
+import re
+from html.parser import HTMLParser
+from typing import Dict, List, Optional
+
+from .errors import ErrorCode, SejongAuthError
+from .models import (
+    ClassicCertification,
+    ClassicContestRecord,
+    ClassicExamRecord,
+    ClassicSubjectRecord,
+    SejongClassicReading,
+    SejongSisUserInfo,
+    SejongStudentInfo,
+)
+
+# 섹션 제목 (포털 화면 문구 그대로, 바꾸면 파싱 실패)
+SECTION_USER_INFO = "사용자 정보"
+SECTION_CERTIFICATIONS = "영역별 인증현황"
+SECTION_EXAMS = "인증 시험 현황"
+SECTION_SUBJECT_SUBSTITUTIONS = "과목 대체 인증 현황"
+SECTION_CONTESTS = "대회 인증 현황"
+SECTION_CURRICULUM = "교과연계 인증 현황"
+
+# 사용자 정보 표 라벨
+LABEL_MAJOR = "학과명"
+LABEL_STUDENT_ID = "학번"
+LABEL_NAME = "이름"
+LABEL_GRADE = "학년"
+LABEL_STATUS = "사용자 상태"
+
+_WHITESPACE = re.compile(r"\s+")
+
+
+class _Cell:
+    def __init__(self, tag: str):
+        self.tag = tag
+        self.text_parts: List[str] = []
+
+    @property
+    def text(self) -> str:
+        return _WHITESPACE.sub(" ", "".join(self.text_parts)).strip()
+
+
+class _Section:
+    def __init__(self):
+        self.title = ""
+        self.rows: List[List[_Cell]] = []
+
+
+class _BoardTableParser(HTMLParser):
+    """div.b-con-box 섹션 > h4.b-h4-tit01 제목 + table.b-board-table tbody 행·칸 수집"""
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.sections: List[_Section] = []
+        self._section: Optional[_Section] = None
+        self._section_div_depth = 0
+        self._is_in_title = False
+        self._is_in_board_table = False
+        self._is_in_tbody = False
+        self._row: Optional[List[_Cell]] = None
+        self._cell: Optional[_Cell] = None
+
+    def handle_starttag(self, tag, attrs):
+        classes = (dict(attrs).get("class") or "").split()
+        if tag == "div":
+            if self._section is not None:
+                self._section_div_depth += 1
+            elif "b-con-box" in classes:
+                self._section = _Section()
+                self._section_div_depth = 1
+            return
+        if self._section is None:
+            return
+        if tag == "h4" and "b-h4-tit01" in classes:
+            self._is_in_title = True
+        elif tag == "table" and "b-board-table" in classes:
+            self._is_in_board_table = True
+        elif tag == "tbody" and self._is_in_board_table:
+            self._is_in_tbody = True
+        elif tag == "tr" and self._is_in_tbody:
+            self._row = []
+        elif tag in ("th", "td") and self._row is not None:
+            self._cell = _Cell(tag)
+
+    def handle_endtag(self, tag):
+        if tag == "div" and self._section is not None:
+            self._section_div_depth -= 1
+            if self._section_div_depth == 0:
+                self.sections.append(self._section)
+                self._section = None
+        elif tag == "h4":
+            self._is_in_title = False
+        elif tag == "table":
+            self._is_in_board_table = False
+            self._is_in_tbody = False
+        elif tag == "tbody":
+            self._is_in_tbody = False
+        elif tag == "tr" and self._row is not None:
+            self._section.rows.append(self._row)
+            self._row = None
+        elif tag in ("th", "td") and self._cell is not None:
+            self._row.append(self._cell)
+            self._cell = None
+
+    def handle_data(self, data):
+        if self._is_in_title and self._section is not None:
+            self._section.title += data
+        elif self._cell is not None:
+            self._cell.text_parts.append(data)
+
+
+def _read_sections(html: str) -> List[_Section]:
+    try:
+        parser = _BoardTableParser()
+        parser.feed(html)
+        parser.close()
+        return parser.sections
+    except Exception as error:  # HTMLParser 내부 오류 > PARSE_ERROR
+        raise SejongAuthError(ErrorCode.PARSE_ERROR) from error
+
+
+def _find_rows(sections: List[_Section], title: str) -> List[List[_Cell]]:
+    for section in sections:
+        if title in section.title:
+            return section.rows
+    return []
+
+
+def _td_texts(row: List[_Cell]) -> List[str]:
+    return [cell.text for cell in row if cell.tag == "td"]
+
+
+def _th_text(row: List[_Cell]) -> str:
+    return " ".join(cell.text for cell in row if cell.tag == "th").strip()
+
+
+def parse_student_info(html: str) -> SejongStudentInfo:
+    """사용자 정보 표 > 학과, 학번, 이름, 학년, 상태 (표 없으면 PARSE_ERROR)"""
+    value_by_label: Dict[str, str] = {}
+    for row in _find_rows(_read_sections(html), SECTION_USER_INFO):
+        label = _th_text(row)
+        if label:
+            value_by_label[label] = " ".join(_td_texts(row)).strip()
+    if not value_by_label:
+        raise SejongAuthError(ErrorCode.PARSE_ERROR, "Student info table not found")
+    return SejongStudentInfo(
+        major=value_by_label.get(LABEL_MAJOR, ""),
+        student_id=value_by_label.get(LABEL_STUDENT_ID, ""),
+        name=value_by_label.get(LABEL_NAME, ""),
+        grade=value_by_label.get(LABEL_GRADE, ""),
+        status=value_by_label.get(LABEL_STATUS, ""),
+    )
+
+
+def parse_classic_reading(html: str) -> SejongClassicReading:
+    """고전독서 5개 표 > SejongClassicReading (칸 수 부족한 행은 건너뜀)"""
+    sections = _read_sections(html)
+
+    certifications = []
+    for row in _find_rows(sections, SECTION_CERTIFICATIONS):
+        area, counts = _th_text(row), _td_texts(row)
+        if area and len(counts) >= 2:
+            certifications.append(ClassicCertification(area, counts[0], counts[1]))
+
+    def rows_with(title: str, minimum_cell_count: int) -> List[List[str]]:
+        return [cells for cells in map(_td_texts, _find_rows(sections, title)) if len(cells) >= minimum_cell_count]
+
+    return SejongClassicReading(
+        certifications=certifications,
+        exam_records=[ClassicExamRecord(*cells[:6]) for cells in rows_with(SECTION_EXAMS, 6)],
+        subject_substitutions=[ClassicSubjectRecord(*cells[:5]) for cells in rows_with(SECTION_SUBJECT_SUBSTITUTIONS, 5)],
+        contest_records=[ClassicContestRecord(*cells[:4]) for cells in rows_with(SECTION_CONTESTS, 4)],
+        curriculum_records=[ClassicSubjectRecord(*cells[:5]) for cells in rows_with(SECTION_CURRICULUM, 5)],
+    )
+
+
+def _text(node: dict, field_name: str) -> str:
+    value = node.get(field_name) if isinstance(node, dict) else None
+    return "" if value is None else str(value)
+
+
+# SIS 오류 응답: 200 + {"_SUBMIT_ERROR_": {"ERRTYPE": ...}}, 로그인 세션 없음(틀린 비밀번호) = LOGOUT
+SIS_SUBMIT_ERROR_KEY = "_SUBMIT_ERROR_"
+SIS_LOGGED_OUT_ERROR_TYPE = "LOGOUT"
+
+
+def ensure_sis_logged_in(json_text: str) -> None:
+    """initUserInfo 오류 응답 판정: LOGOUT > AUTHENTICATION_FAILED, 그 외 오류 > DATA_FETCH_FAILED"""
+    try:
+        root = json.loads(json_text)
+    except (TypeError, ValueError):
+        return  # JSON 아님 > 파싱 단계에서 PARSE_ERROR
+    submit_error = root.get(SIS_SUBMIT_ERROR_KEY) if isinstance(root, dict) else None
+    if not isinstance(submit_error, dict):
+        return
+    error_type = _text(submit_error, "ERRTYPE")
+    if error_type == SIS_LOGGED_OUT_ERROR_TYPE:
+        raise SejongAuthError(ErrorCode.AUTHENTICATION_FAILED)
+    raise SejongAuthError(ErrorCode.DATA_FETCH_FAILED, f"SIS returned an error : {error_type}")
+
+
+def parse_sis_user_info(json_text: str) -> SejongSisUserInfo:
+    """initUserInfo JSON > 학번, 이름, 학과, 이메일, 전화번호, 영문 이름 (dm_UserInfo 없으면 PARSE_ERROR)"""
+    try:
+        root = json.loads(json_text)
+    except (TypeError, ValueError) as error:
+        raise SejongAuthError(ErrorCode.PARSE_ERROR) from error
+    if not isinstance(root, dict) or not isinstance(root.get("dm_UserInfo"), dict):
+        raise SejongAuthError(ErrorCode.PARSE_ERROR, "dm_UserInfo field not found")
+
+    user_info = root["dm_UserInfo"]
+    gam = root.get("dm_UserInfoGam") or {}
+    sch = root.get("dm_UserInfoSch") or {}
+    phone_parts = [_text(gam, key).strip() for key in ("USER_PHONE_NO1", "USER_PHONE_NO2", "USER_PHONE_NO3")]
+
+    return SejongSisUserInfo(
+        student_id=_text(user_info, "INTG_USR_NO"),
+        name=_text(user_info, "INTG_USR_NM"),
+        major=_text(gam, "DEPT_NM").strip() or _text(sch, "DEPT_NM"),
+        email=_text(gam, "USER_EMAIL"),
+        phone_number="-".join(part for part in phone_parts if part),
+        english_name=_text(user_info, "INTG_ENG_NM").strip() or _text(sch, "NM_ENG"),
+    )

pro_sejong_auth-1.2.16/src/sejong_auth/transport.py

@@ -0,0 +1,64 @@
+"""HTTP 세션: 인증 1회당 쿠키 저장소 1개, 포털 레거시 TLS, 리다이렉트 자동 (표준 라이브러리만)"""
+
+import http.cookiejar
+import socket
+import ssl
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+# 포털은 TLS_RSA_WITH_AES_256_CBC_SHA 만 제공 > 기본 cipher 목록에 추가 (spec/PORTAL_FLOW.md)
+PORTAL_CIPHERS = "DEFAULT:AES256-SHA:@SECLEVEL=1"
+
+
+@dataclass(frozen=True)
+class HttpResponse:
+    status: int
+    body: bytes
+
+    @property
+    def is_successful(self) -> bool:
+        return 200 <= self.status < 300
+
+    def text(self) -> str:
+        return self.body.decode("utf-8", errors="replace")
+
+
+def create_ssl_context(ssl_verification: bool) -> ssl.SSLContext:
+    """포털 cipher 허용 컨텍스트 (ssl_verification=False 면 인증서·호스트 검증 해제)"""
+    context = ssl.create_default_context()
+    context.set_ciphers(PORTAL_CIPHERS)
+    if not ssl_verification:
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+    return context
+
+
+class UrllibSession:
+    """요청 1건: 상태 코드가 4xx·5xx 여도 예외 대신 HttpResponse, 시간 초과는 TimeoutError"""
+
+    def __init__(self, ssl_context: ssl.SSLContext, timeout_seconds: float, user_agent: str):
+        self._timeout_seconds = timeout_seconds
+        self._opener = urllib.request.build_opener(
+            urllib.request.HTTPSHandler(context=ssl_context),
+            urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()),
+        )
+        # 기본 Python-urllib 에이전트는 포털 방화벽이 차단
+        self._opener.addheaders = [("User-Agent", user_agent)]
+
+    def request(self, method: str, url: str, *, data: Optional[bytes] = None,
+                headers: Optional[Dict[str, str]] = None) -> HttpResponse:
+        request = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
+        try:
+            with self._opener.open(request, timeout=self._timeout_seconds) as response:
+                return HttpResponse(status=response.status, body=response.read())
+        except urllib.error.HTTPError as error:
+            with error:
+                return HttpResponse(status=error.code, body=error.read() or b"")
+        except urllib.error.URLError as error:
+            if isinstance(error.reason, (socket.timeout, TimeoutError)):
+                raise TimeoutError(str(error.reason)) from error
+            raise OSError(str(error.reason)) from error
+        except socket.timeout as error:
+            raise TimeoutError(str(error)) from error

pro_sejong_auth-1.2.16/tests/conftest.py

@@ -0,0 +1,54 @@
+"""테스트 공통: spec/fixtures 읽기, 네트워크 없는 가짜 세션"""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from sejong_auth.transport import HttpResponse
+
+FIXTURE_DIRECTORY = Path(__file__).resolve().parents[2] / "spec" / "fixtures"
+
+
+def read_fixture(file_name: str) -> str:
+    return (FIXTURE_DIRECTORY / file_name).read_text(encoding="utf-8")
+
+
+def read_expected(file_name: str) -> dict:
+    return json.loads(read_fixture(file_name))
+
+
+class FakeSession:
+    """URL 앞부분 > 응답 목록(차례로 소비). 값이 예외 인스턴스면 raise"""
+
+    def __init__(self, responses_by_url_prefix):
+        self.responses_by_url_prefix = {prefix: list(responses) for prefix, responses in responses_by_url_prefix.items()}
+        self.requested_urls = []
+
+    def request(self, method, url, *, data=None, headers=None):
+        self.requested_urls.append(url)
+        for prefix, responses in self.responses_by_url_prefix.items():
+            if url.startswith(prefix):
+                outcome = responses.pop(0) if len(responses) > 1 else responses[0]
+                if isinstance(outcome, BaseException):
+                    raise outcome
+                return outcome
+        raise AssertionError(f"unexpected request: {method} {url}")
+
+
+def ok(body: str = "") -> HttpResponse:
+    return HttpResponse(status=200, body=body.encode("utf-8"))
+
+
+def status(code: int) -> HttpResponse:
+    return HttpResponse(status=code, body=b"")
+
+
+@pytest.fixture
+def dhc_html() -> str:
+    return read_fixture("dhc_status.html")
+
+
+@pytest.fixture
+def sis_json() -> str:
+    return read_fixture("sis_user_info.json")

pro_sejong_auth-1.2.16/tests/test_client.py

@@ -0,0 +1,134 @@
+"""클라이언트 흐름: 입력 검증, 401, SIS 실패 무시, 타임아웃, 재시도 (네트워크 없음)"""
+
+import pytest
+from conftest import FakeSession, ok, status
+
+from sejong_auth import ErrorCode, SejongAuthClient, SejongAuthError
+
+LOGIN = "https://portal.sejong.ac.kr/jsp/login/login_action.jsp"
+CLASSIC_SSO = "https://classic.sejong.ac.kr/_custom/sejong/sso/sso-return.jsp"
+CLASSIC_STATUS = "https://classic.sejong.ac.kr/classic/reading/status.do"
+SIS_SSO = "https://sjpt.sejong.ac.kr/main/view/Login/doSsoLogin.do"
+SIS_USER_INFO = "https://sjpt.sejong.ac.kr/main/sys/UserInfo/initUserInfo.do"
+
+
+def client_with(responses_by_url_prefix, **options):
+    sessions = []
+
+    def session_factory():
+        session = FakeSession(responses_by_url_prefix)
+        sessions.append(session)
+        return session
+
+    return SejongAuthClient(_session_factory=session_factory, **options), sessions
+
+
+@pytest.mark.parametrize("student_id,password", [("", "pw"), ("21011234", ""), ("   ", "pw"), (None, "pw")])
+def test_empty_input_raises_invalid_input_without_network(student_id, password):
+    client, sessions = client_with({})
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate(student_id, password)
+
+    assert error.value.code == ErrorCode.INVALID_INPUT
+    assert sessions == []
+
+
+def test_wrong_password_401_raises_authentication_failed():
+    client, _ = client_with({LOGIN: [ok()], CLASSIC_SSO: [ok()], CLASSIC_STATUS: [status(401)]})
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate_dhc("21011234", "wrong")
+
+    assert error.value.code == ErrorCode.AUTHENTICATION_FAILED
+
+
+def test_integrated_sis_failure_returns_dhc_with_null_contacts(dhc_html):
+    client, _ = client_with({
+        LOGIN: [ok()], CLASSIC_SSO: [ok()], CLASSIC_STATUS: [ok(dhc_html)],
+        SIS_SSO: [ok()], SIS_USER_INFO: [status(500)],
+    })
+
+    result = client.authenticate("21011234", "pw")
+
+    assert result.success is True
+    assert result.name == "홍길동"
+    assert result.major == "컴퓨터공학과"
+    assert (result.email, result.phone_number, result.english_name) == (None, None, None)
+
+
+def test_integrated_success_merges_dhc_and_sis(dhc_html, sis_json):
+    client, _ = client_with({
+        LOGIN: [ok()], CLASSIC_SSO: [ok()], CLASSIC_STATUS: [ok(dhc_html)],
+        SIS_SSO: [ok()], SIS_USER_INFO: [ok(sis_json)],
+    })
+
+    result = client.authenticate("21011234", "pw")
+
+    assert result.grade == "3"
+    assert result.classic_reading.certifications[2].area == "동·서양의 문학 (3권)"
+    assert result.phone_number == "010-1234-5678"
+    assert result.english_name == "Hong Gildong"
+
+
+def test_timeout_raises_connection_timeout():
+    client, _ = client_with({LOGIN: [TimeoutError("timed out")]}, max_retry=3)
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate_dhc("21011234", "pw")
+
+    assert error.value.code == ErrorCode.CONNECTION_TIMEOUT
+
+
+def test_retry_exhausted_raises_connection_failed():
+    client, sessions = client_with({LOGIN: [status(500)]}, max_retry=3)
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate_dhc("21011234", "pw")
+
+    assert error.value.code == ErrorCode.CONNECTION_FAILED
+    assert sessions[0].requested_urls.count(LOGIN) == 3
+
+
+def test_retry_then_success(dhc_html):
+    client, _ = client_with({LOGIN: [status(503), ok()], CLASSIC_SSO: [ok()], CLASSIC_STATUS: [ok(dhc_html)]})
+
+    assert client.authenticate_dhc("21011234", "pw").student_id == "21011234"
+
+
+def test_sis_result_has_empty_grade_and_status_and_raw_json(sis_json):
+    client, _ = client_with({LOGIN: [ok()], SIS_SSO: [ok()], SIS_USER_INFO: [ok(sis_json)]})
+
+    result = client.authenticate_sis("21011234", "pw", include_raw=True)
+
+    assert (result.grade, result.status) == ("", "")
+    assert result.email == "student@example.com"
+    assert result.raw_json == sis_json
+
+
+def test_dhc_raw_html_only_when_requested(dhc_html):
+    client, _ = client_with({LOGIN: [ok()], CLASSIC_SSO: [ok()], CLASSIC_STATUS: [ok(dhc_html)]})
+
+    assert client.authenticate_dhc("21011234", "pw").raw_html is None
+    assert client.authenticate_dhc("21011234", "pw", include_raw=True).raw_html == dhc_html
+
+
+def test_error_message_never_contains_password():
+    client, _ = client_with({LOGIN: [OSError("connection reset")]})
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate_dhc("21011234", "secret-password-value")
+
+    assert error.value.code == ErrorCode.CONNECTION_FAILED
+    assert "secret-password-value" not in str(error.value)
+
+
+def test_sis_wrong_password_submit_error_raises_authentication_failed():
+    # 틀린 비밀번호: initUserInfo 가 200 + _SUBMIT_ERROR_(ERRTYPE LOGOUT) 를 돌려줌
+    from conftest import read_fixture
+    client, _ = client_with({LOGIN: [ok()], SIS_SSO: [ok()], SIS_USER_INFO: [ok(read_fixture("sis_submit_error_logout.json"))]})
+
+    with pytest.raises(SejongAuthError) as error:
+        client.authenticate_sis("21011234", "wrong")
+
+    assert error.value.code == ErrorCode.AUTHENTICATION_FAILED

pro_sejong_auth-1.2.16/tests/test_live.py

@@ -0,0 +1,31 @@
+"""실제 세종 포털 연동 (환경변수 SEJONG_TEST_STUDENT_ID, SEJONG_TEST_PASSWORD 있을 때만)"""
+
+import os
+
+import pytest
+
+from sejong_auth import ErrorCode, SejongAuthError, authenticate, authenticate_dhc, authenticate_sis
+
+STUDENT_ID = os.environ.get("SEJONG_TEST_STUDENT_ID")
+PASSWORD = os.environ.get("SEJONG_TEST_PASSWORD")
+
+pytestmark = pytest.mark.skipif(not (STUDENT_ID and PASSWORD), reason="SEJONG_TEST_* not set")
+
+
+def test_live_integrated():
+    result = authenticate(STUDENT_ID, PASSWORD)
+    assert result.student_id == STUDENT_ID
+    assert result.major and result.name
+    assert result.classic_reading.certifications
+    assert result.email is not None
+
+
+def test_live_dhc_and_sis():
+    assert authenticate_dhc(STUDENT_ID, PASSWORD).student_id == STUDENT_ID
+    assert authenticate_sis(STUDENT_ID, PASSWORD).student_id == STUDENT_ID
+
+
+def test_live_wrong_password():
+    with pytest.raises(SejongAuthError) as error:
+        authenticate_dhc(STUDENT_ID, PASSWORD + "-wrong")
+    assert error.value.code == ErrorCode.AUTHENTICATION_FAILED

pro_sejong_auth-1.2.16/tests/test_parsers.py

@@ -0,0 +1,39 @@
+"""spec/fixtures 파싱 결과 == 기대값 (Java, Node 와 같은 기준)"""
+
+import re
+
+from conftest import read_expected
+
+from sejong_auth.parsers import parse_classic_reading, parse_sis_user_info, parse_student_info
+
+
+def to_snake_case(name: str) -> str:
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
+
+
+def snake_case_keys(value):
+    if isinstance(value, dict):
+        return {to_snake_case(key): snake_case_keys(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [snake_case_keys(item) for item in value]
+    return value
+
+
+def test_parse_dhc_fixture(dhc_html):
+    expected = snake_case_keys(read_expected("expected_dhc.json"))
+
+    assert parse_student_info(dhc_html).to_dict() == expected["student_info"]
+    assert parse_classic_reading(dhc_html).to_dict() == expected["classic_reading"]
+
+
+def test_parse_sis_fixture(sis_json):
+    expected = snake_case_keys(read_expected("expected_sis.json"))
+
+    assert parse_sis_user_info(sis_json).to_dict() == expected
+
+
+def test_decodes_common_named_entities():
+    # Node·Jsoup 과 같은 기대값
+    html = ('<div class="b-con-box"><h4 class="b-h4-tit01">사용자 정보</h4><table class="b-board-table"><tbody>'
+            '<tr><th>학과명</th><td>&lsquo;컴퓨터&rsquo; &ldquo;공학&rdquo;&hellip; &ndash;&mdash;</td></tr></tbody></table></div>')
+    assert parse_student_info(html).major == "‘컴퓨터’ “공학”… –—"