feat(user): report on another user's time entries

- Add user_id parameter to fetch_issues_with_spent_time().
- Support numeric ID, login, or full name resolution.
- Reject ambiguous names and unknown users with clear messages.
- Add CLI flags: --user-id, --user-login, --user-name.
- Only allow one user flag at a time.
- Add ResourceNotFoundError handling.
- Update README with usage examples.
- Add tests for user resolution and CLI flags.

Closes #40

README.md

@@ -8,18 +8,15 @@ CLI-инструмент для генерации отчётов по зада
 
 ## Возможности
 
-- Получение time entries текущего пользователя из Redmine.
-- Авторизация через Redmine API token.
-- Резервная авторизация через логин и пароль для обратной совместимости.
+- Получение time entries **текущего** или **указанного** пользователя из Redmine.
+- Авторизация через Redmine API token или логин/пароль.
 - Группировка задач по проекту и версии.
 - Перевод статусов задач на русский язык.
-- Вывод в консоль в табличном или компактном виде.
+- Вывод в консоль (таблица / компактный вид).
 - Экспорт в ODT, CSV, Markdown, HTML, JSON и Excel (.xlsx).
-- Сводка по затраченному времени (итоги и разбивка по проектам/версиям).
-- Автоматическое определение месяца ODT-отчёта по конечной дате периода.
-- Настройка периода отчёта по умолчанию через `.env` (или автоматически — текущий месяц).
-- Переопределение URL и API-ключа через CLI.
-- Загрузка альтернативного `.env` через `--config`.
+- Excel-отчёт с merge-ячейками по проекту/версии, итогами, автошириной, автофильтром и закреплённой шапкой.
+- Сводка по времени (`--summary`).
+- Понятные сообщения об ошибках Redmine API (401/403/5xx, таймаут, сеть).
 - Загрузка альтернативного `.env` через `--config`.
 
 ## Установка
@@ -33,9 +30,15 @@ pip install --upgrade pip
 pip install .
 ```
 
+Для разработки:
+
+```bash
+pip install -e ".[dev]"
+```
+
 ## Настройка
 
-Создайте файл `.env` в корне проекта. Файл не должен попадать в git.
+Создайте файл `.env` в корне проекта. Он не должен попадать в git.
 
 Рекомендуемый вариант авторизации:
 
@@ -48,18 +51,13 @@ DEFAULT_FROM_DATE=2026-01-01
 DEFAULT_TO_DATE=2026-01-31
 ```
 
-Если задан `REDMINE_API_KEY`, он используется в первую очередь. Значения из `.env` можно переопределить через CLI: `--url`, `--api-key`, `--author`, а также загрузить другой файл конфигурации через `--config`.
-
-Резервный вариант авторизации:
+Резервный вариант:
 
 ```ini
 REDMINE_URL=https://red.eltex.loc/
 REDMINE_USER=ваш.логин
 REDMINE_PASSWORD=ваш_пароль
 REDMINE_AUTHOR=Иванов Иван Иванович
-
-DEFAULT_FROM_DATE=2026-01-01
-DEFAULT_TO_DATE=2026-01-31
 ```
 
 Переменные окружения:
@@ -71,18 +69,9 @@ DEFAULT_TO_DATE=2026-01-31
 | `REDMINE_USER` | Да, если нет токена | Логин Redmine. |
 | `REDMINE_PASSWORD` | Да, если нет токена | Пароль Redmine. |
 | `REDMINE_AUTHOR` | Нет | Имя автора для ODT-отчёта. |
-| `DEFAULT_FROM_DATE` | Нет | Начальная дата периода по умолчанию в формате `YYYY-MM-DD`. |
-| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию в формате `YYYY-MM-DD`. |
-| `REDMINE_VERIFY` | Нет | Настройка TLS-проверки для Redmine API. |
-
-`REDMINE_VERIFY` поддерживает значения:
-
-- пустое значение или отсутствие переменной: `/etc/ssl/certs/ca-certificates.crt`;
-- `true`, `1`, `yes`, `on`: стандартная проверка сертификатов `requests`;
-- `false`, `0`, `no`, `off`: отключить проверку сертификатов;
-- любой другой текст: путь к CA bundle.
-
-Отключать проверку сертификатов не рекомендуется.
+| `DEFAULT_FROM_DATE` | Нет | Начальная дата периода по умолчанию (`YYYY-MM-DD`). |
+| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию (`YYYY-MM-DD`). |
+| `REDMINE_VERIFY` | Нет | TLS-проверка: `true` / `false` / путь к CA bundle. |
 
 ## Использование
 
@@ -90,7 +79,7 @@ DEFAULT_TO_DATE=2026-01-31
 source .venv/bin/activate
 ```
 
-Отчёт за период по умолчанию (текущий месяц или из `.env`):
+Отчёт за период по умолчанию:
 
 ```bash
 redmine-reporter
@@ -102,15 +91,23 @@ redmine-reporter
 redmine-reporter --date 2026-02-01--2026-02-28
 ```
 
-Период должен быть задан в формате `YYYY-MM-DD--YYYY-MM-DD`. Начальная дата не может быть позже конечной.
+Отчёт по другому пользователю:
 
-Переопределение URL и API-ключа из `.env`:
+```bash
+redmine-reporter --user-id 42
+redmine-reporter --user-login ivanov
+redmine-reporter --user-name "Иванов И.И."
+```
+
+`--user-name` требует точного совпадения; если найдено несколько пользователей, CLI сообщает об ошибке и просит использовать `--user-id`.
+
+Переопределить URL/API-ключ из `.env`:
 
 ```bash
 redmine-reporter --url https://red.example.com --api-key ваш_токен
 ```
 
-Использование альтернативного конфигурационного файла:
+Альтернативный конфигурационный файл:
 
 ```bash
 redmine-reporter --config /path/to/.env
@@ -122,19 +119,12 @@ redmine-reporter --config /path/to/.env
 redmine-reporter --compact
 ```
 
-Подробный или отладочный вывод:
+Отладочный вывод:
 
 ```bash
-redmine-reporter --verbose
 redmine-reporter --debug
 ```
 
-Вывод версии:
-
-```bash
-redmine-reporter --version
-```
-
 Экспорт:
 
 ```bash
@@ -146,60 +136,40 @@ redmine-reporter --output report.json
 redmine-reporter --output report.xlsx
 ```
 
-JSON-отчёт:
-
-- массив объектов с полями `project`, `version`, `issue_id`, `subject`, `status`, `time`;
-- UTF-8, читаемый машиной.
-
-Excel-отчёт (.xlsx):
-
-- одна таблица с заголовками и строками данных;
-- шапка выделена жирным;
-- каждая строка содержит полные значения проекта и версии.
-
-CSV-отчёт:
-
-- файл сохраняется в UTF-8 с BOM (`utf-8-sig`) для корректного отображения кириллицы в Microsoft Excel;
-- каждая строка содержит полные значения проекта и версии (в отличие от консольного и Markdown-вывода, где повторяющиеся значения скрыты для компактности).
-
-HTML-отчёт:
-
-- полноценный HTML-документ с `<meta charset="utf-8">`;
-- корректно отображается в браузере и почтовых клиентах.
-
-ODT-отчёт:
-
-- месяц в заголовке определяется по `to_date`;
-- имя автора берётся из `--author`, затем из `REDMINE_AUTHOR`;
-- если автор не задан, поле автора остаётся пустым.
-
-Вывод без затраченного времени:
+Отчёт без затраченного времени (работает для всех форматов):
 
 ```bash
 redmine-reporter --no-time
+redmine-reporter --no-time --output report.xlsx
 ```
 
-Сводка по времени (итоги и разбивка по проектам):
+Сводка по времени:
 
 ```bash
 redmine-reporter --summary
 ```
 
+## Форматы вывода
+
+| Формат | Особенности |
+| --- | --- |
+| **ODT** | Заголовок с автором и месяцем, группировка по проекту/версии. |
+| **CSV** | UTF-8 с BOM, полные значения `project`/`version` в каждой строке. |
+| **Markdown** | Компактная таблица, повторяющиеся группы скрыты. |
+| **HTML** | Полноценный HTML-документ с `meta charset="utf-8"`. |
+| **JSON** | Массив объектов: `project`, `version`, `issue_id`, `subject`, `status`, `time`. |
+| **Excel (.xlsx)** | Merge cells, колонки `Hours`/`Spent Time`, итоги, автоширина, автофильтр, freeze panes. |
+
 ## Разработка
 
-Установка зависимостей для разработки:
-
-```bash
-pip install -e ".[dev]"
-```
-
-Проверки:
+Проверки перед коммитом:
 
 ```bash
 pytest
 ruff check redmine_reporter tests
-black redmine_reporter tests
-isort redmine_reporter tests
+black --check redmine_reporter tests
+isort --check-only redmine_reporter tests
+mypy redmine_reporter
 ```
 
 ## Безопасность

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redmine-reporter"
-version = "1.6.0"
+version = "1.7.0"
 description = "Redmine time-entry based issue reporter for internal use"
 readme = "README.md"
 authors = [{ name = "Artem Kokos", email = "artem-kokos@mail.ru" }]

redmine_reporter/__init__.py

@@ -1 +1 @@
-__version__ = "1.6.1"
+__version__ = "1.7.0"

redmine_reporter/cli.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from typing import List, Optional
 
 from . import __version__
-from .client import fetch_issues_with_spent_time
+from .client import RedmineAPIError, fetch_issues_with_spent_time
 from .config import Config
 from .formatters.factory import get_console_formatter, get_formatter_by_extension
 from .report_builder import build_grouped_report, calculate_summary
@@ -76,8 +76,29 @@ def main(argv: Optional[List[str]] = None) -> int:
         action="store_true",
         help="Print summary (total hours by project/version) to stderr",
     )
+    parser.add_argument(
+        "--user-id",
+        help="Redmine user ID for the report (default: current user)",
+    )
+    parser.add_argument(
+        "--user-login",
+        help="Redmine user login for the report (alternative to --user-id)",
+    )
+    parser.add_argument(
+        "--user-name",
+        help="Redmine user full name for the report (alternative to --user-id; ambiguous names are rejected)",
+    )
     args = parser.parse_args(argv)
 
+    # Валидация взаимоисключающих флагов пользователя
+    user_args = [args.user_id, args.user_login, args.user_name]
+    if sum(bool(a) for a in user_args) > 1:
+        print(
+            "❌ Specify only one of --user-id, --user-login, or --user-name.",
+            file=sys.stderr,
+        )
+        return 1
+
     # CLI-переопределения имеют приоритет над .env/env.
     if args.config:
         Config.load_config(args.config)
@@ -105,9 +126,18 @@ def main(argv: Optional[List[str]] = None) -> int:
         return 1
 
     try:
-        issue_hours = fetch_issues_with_spent_time(from_date, to_date)
+        issue_hours = fetch_issues_with_spent_time(
+            from_date,
+            to_date,
+            user_id=args.user_id or args.user_login or args.user_name,
+        )
+    except RedmineAPIError as e:
+        print(f"❌ {e.message}", file=sys.stderr)
+        if args.debug and e.original is not None:
+            logging.exception("Original Redmine API error")
+        return 1
     except Exception as e:
-        print(f"❌ Redmine API error: {e}", file=sys.stderr)
+        print(f"❌ Unexpected error: {e}", file=sys.stderr)
         return 1
 
     if issue_hours is None:

redmine_reporter/client.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import requests
 from redminelib import Redmine
+from redminelib.exceptions import AuthError, ForbiddenError, ResourceNotFoundError
 from redminelib.resources import Issue
 from urllib3.util.retry import Retry
 
@@ -14,6 +15,15 @@ REQUEST_TIMEOUT = 30
 ISSUE_ID_CHUNK_SIZE = 100
 
 
+class RedmineAPIError(Exception):
+    """Пользовательское исключение с понятным сообщением об ошибке Redmine API."""
+
+    def __init__(self, message: str, original: Optional[Exception] = None):
+        super().__init__(message)
+        self.message = message
+        self.original = original
+
+
 def _get_redmine_auth_kwargs() -> Dict[str, Any]:
     """Return Redmine auth kwargs. API key has priority over legacy password auth."""
     api_key = Config.get_redmine_api_key()
@@ -56,6 +66,51 @@ def _create_redmine() -> Redmine:
     return redmine
 
 
+def _format_redmine_error(exc: Exception) -> str:
+    """Преобразует исключение Redmine/requests в понятное сообщение."""
+    if isinstance(exc, AuthError):
+        return (
+            "Authentication failed: invalid API key, login or password. "
+            "Check REDMINE_API_KEY / REDMINE_USER / REDMINE_PASSWORD."
+        )
+    if isinstance(exc, ForbiddenError):
+        return (
+            "Access denied: your Redmine account does not have permission "
+            "to read time entries or issues."
+        )
+    if isinstance(exc, ResourceNotFoundError):
+        return "Requested Redmine resource not found: check user/project identifiers."
+
+    # requests HTTPError может быть обёрнуто в python-redmine
+    original = getattr(exc, "response", None)
+    if original is None:
+        original = exc
+
+    response = getattr(original, "response", None)
+    if response is not None and hasattr(response, "status_code"):
+        status = response.status_code
+        if status == 401:
+            return "Authentication failed (HTTP 401): check your API key or login/password."
+        if status == 403:
+            return "Access denied (HTTP 403): insufficient Redmine permissions."
+        if status == 404:
+            return "Redmine endpoint not found (HTTP 404): check REDMINE_URL."
+        if status == 429:
+            return "Too many requests (HTTP 429): Redmine rate limit exceeded."
+        if 500 <= status < 600:
+            return f"Redmine server error (HTTP {status}): try again later."
+        return f"Redmine API returned HTTP {status}."
+
+    if isinstance(exc, requests.exceptions.Timeout):
+        return f"Redmine request timed out after {REQUEST_TIMEOUT} seconds."
+    if isinstance(exc, requests.exceptions.ConnectionError):
+        return "Cannot connect to Redmine: check the URL and network."
+    if isinstance(exc, requests.exceptions.RequestException):
+        return f"Network error while calling Redmine: {exc}"
+
+    return str(exc)
+
+
 def _fetch_issues_chunked(redmine: Redmine, issue_ids: List[int]) -> List[Issue]:
     """Загружает задачи чанками, чтобы не превышать лимит длины URL (#21)."""
     all_issues: List[Issue] = []
@@ -67,21 +122,93 @@ def _fetch_issues_chunked(redmine: Redmine, issue_ids: List[int]) -> List[Issue]
     return all_issues
 
 
+def _resolve_user_id(redmine: Redmine, user_arg: Union[int, str]) -> int:
+    """Преобразует строковый идентификатор пользователя в числовой ID.
+
+    Если аргумент — число, возвращает его как есть.
+    Если строка, пытается найти пользователя по логину или имени.
+    """
+    if isinstance(user_arg, int):
+        return user_arg
+
+    text = str(user_arg).strip()
+    if not text:
+        raise RedmineAPIError("User identifier cannot be empty.")
+
+    # Сначала пробуем интерпретировать как числовой ID
+    if text.isdigit():
+        return int(text)
+
+    # Затем ищем по логину
+    try:
+        users = redmine.user.filter(login=text)
+        if users:
+            return int(users[0].id)
+    except Exception as exc:
+        raise RedmineAPIError(
+            f"Cannot resolve user login '{text}': {_format_redmine_error(exc)}",
+            original=exc,
+        ) from exc
+
+    # Потом по имени
+    try:
+        users = redmine.user.filter(name=text)
+        if len(users) == 1:
+            return int(users[0].id)
+        if len(users) > 1:
+            matches = ", ".join(str(getattr(u, "login", u.id)) for u in users[:5])
+            raise RedmineAPIError(
+                f"Multiple users match '{text}': {matches}. Use --user-id with numeric ID."
+            )
+    except RedmineAPIError:
+        raise
+    except Exception as exc:
+        raise RedmineAPIError(
+            f"Cannot resolve user name '{text}': {_format_redmine_error(exc)}",
+            original=exc,
+        ) from exc
+
+    raise RedmineAPIError(
+        f"User '{text}' not found. Check the login/name or use --user-id with numeric Redmine ID."
+    )
+
+
+def _get_current_user_id(redmine: Redmine) -> int:
+    """Возвращает ID текущего пользователя."""
+    try:
+        current_user = redmine.user.get("current")
+        return int(current_user.id)
+    except Exception as exc:
+        raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
+
+
 def fetch_issues_with_spent_time(
-    from_date: str, to_date: str
+    from_date: str,
+    to_date: str,
+    user_id: Optional[Union[int, str]] = None,
 ) -> Optional[List[Tuple[Issue, float]]]:
     """
-    Fetch unique issues linked to time entries of the current user in given date range,
+    Fetch unique issues linked to time entries of the given user in date range,
     along with total spent hours per issue.
+    If user_id is None, uses current user.
     Returns list of (issue, total_hours) tuples.
+    Raises RedmineAPIError on API/auth/network failures.
     """
 
+    try:
         redmine = _create_redmine()
-
-    current_user = redmine.user.get("current")
-    time_entries = redmine.time_entry.filter(
-        user_id=current_user.id, from_date=from_date, to_date=to_date
+        target_user_id = (
+            _resolve_user_id(redmine, user_id)
+            if user_id is not None
+            else _get_current_user_id(redmine)
         )
+        time_entries = redmine.time_entry.filter(
+            user_id=target_user_id, from_date=from_date, to_date=to_date
+        )
+    except RedmineAPIError:
+        raise
+    except Exception as exc:
+        raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
 
     # Агрегируем часы по issue.id
     spent_time: Dict[int, float] = {}
@@ -96,8 +223,11 @@ def fetch_issues_with_spent_time(
         return None
 
     # Загружаем полные объекты задач чанками (#21)
+    try:
         sorted_ids = sorted(issue_ids)
         issues = _fetch_issues_chunked(redmine, sorted_ids)
+    except Exception as exc:
+        raise RedmineAPIError(_format_redmine_error(exc), original=exc) from exc
 
     # Сопоставляем задачи с суммарным временем.
     # Сортировка выполняется в report_builder.build_grouped_report,

tests/test_cli.py

@@ -210,6 +210,46 @@ def test_total_issues_message_goes_to_stderr(mock_fetch, capsys):
     assert "Total issues" in captured.err
 
 
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_prints_readable_auth_error(mock_fetch, capsys):
+    """CLI выводит понятное сообщение при ошибке аутентификации."""
+    from redmine_reporter.client import RedmineAPIError
+
+    mock_fetch.side_effect = RedmineAPIError("Authentication failed: bad key")
+    code = main(["--date", "2026-01-01--2026-01-31"])
+    captured = capsys.readouterr()
+    assert code == 1
+    assert "Authentication failed" in captured.err
+    assert "Redmine API error" not in captured.err
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_prints_readable_forbidden_error(mock_fetch, capsys):
+    """CLI выводит понятное сообщение при недостаточных правах."""
+    from redmine_reporter.client import RedmineAPIError
+
+    mock_fetch.side_effect = RedmineAPIError("Access denied: no permission")
+    code = main(["--date", "2026-01-01--2026-01-31"])
+    captured = capsys.readouterr()
+    assert code == 1
+    assert "Access denied" in captured.err
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_prints_readable_timeout_error(mock_fetch, capsys):
+    """CLI выводит понятное сообщение при таймауте."""
+    from redmine_reporter.client import RedmineAPIError
+
+    mock_fetch.side_effect = RedmineAPIError("Redmine request timed out after 30 seconds")
+    code = main(["--date", "2026-01-01--2026-01-31"])
+    captured = capsys.readouterr()
+    assert code == 1
+    assert "timed out" in captured.err
+
+
 @mock.patch.dict(os.environ, VALID_ENV, clear=True)
 @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
 def test_cli_no_time_passed_to_formatter(mock_fetch, tmp_path):
@@ -225,3 +265,39 @@ def test_cli_no_time_passed_to_formatter(mock_fetch, tmp_path):
 
     _, kwargs = mock_get_formatter.call_args
     assert kwargs.get("no_time") is True
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_passes_user_id_to_fetch(mock_fetch):
+    """CLI --user-id передаётся в fetch_issues_with_spent_time."""
+    mock_fetch.return_value = None
+    main(["--date", "2026-01-01--2026-01-31", "--user-id", "42"])
+    _, kwargs = mock_fetch.call_args
+    assert kwargs["user_id"] == "42"
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_passes_user_login_to_fetch(mock_fetch):
+    """CLI --user-login передаётся в fetch_issues_with_spent_time."""
+    mock_fetch.return_value = None
+    main(["--date", "2026-01-01--2026-01-31", "--user-login", "ivanov"])
+    _, kwargs = mock_fetch.call_args
+    assert kwargs["user_id"] == "ivanov"
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+def test_cli_rejects_multiple_user_flags():
+    """CLI не принимает одновременно несколько флагов пользователя."""
+    code = main(
+        [
+            "--date",
+            "2026-01-01--2026-01-31",
+            "--user-id",
+            "42",
+            "--user-login",
+            "ivanov",
+        ]
+    )
+    assert code == 1

tests/test_client.py

@@ -1,6 +1,8 @@
 import os
 from unittest import mock
 
+import pytest
+
 from redmine_reporter.client import fetch_issues_with_spent_time
 from redmine_reporter.config import DEFAULT_REDMINE_VERIFY
 
@@ -168,6 +170,191 @@ def test_fetch_uses_custom_verify_path(mock_redmine_class):
     assert kwargs["requests"]["verify"] == "/tmp/redmine-ca.pem"
 
 
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_raises_redmine_api_error_on_auth(mock_redmine_class):
+    """AuthError превращается в RedmineAPIError с понятным сообщением."""
+    from redminelib.exceptions import AuthError
+
+    mock_redmine = mock_redmine_class.return_value
+    mock_redmine.user.get.side_effect = AuthError()
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="Authentication failed"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_raises_redmine_api_error_on_forbidden(mock_redmine_class):
+    """ForbiddenError превращается в RedmineAPIError с понятным сообщением."""
+    from redminelib.exceptions import ForbiddenError
+
+    mock_redmine = mock_redmine_class.return_value
+    mock_redmine.user.get.side_effect = ForbiddenError()
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="Access denied"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_raises_redmine_api_error_on_timeout(mock_redmine_class):
+    """requests Timeout превращается в RedmineAPIError с понятным сообщением."""
+    import requests
+
+    mock_redmine = mock_redmine_class.return_value
+    mock_redmine.user.get.side_effect = requests.exceptions.Timeout("timeout")
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="timed out"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_raises_redmine_api_error_on_connection_error(mock_redmine_class):
+    """ConnectionError превращается в RedmineAPIError с понятным сообщением."""
+    import requests
+
+    mock_redmine = mock_redmine_class.return_value
+    mock_redmine.user.get.side_effect = requests.exceptions.ConnectionError("no route")
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="Cannot connect"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_raises_redmine_api_error_on_http_500(mock_redmine_class):
+    """HTTP 500 превращается в RedmineAPIError с понятным сообщением."""
+    import requests
+
+    mock_redmine = mock_redmine_class.return_value
+    response = requests.Response()
+    response.status_code = 500
+    mock_redmine.user.get.side_effect = requests.exceptions.HTTPError(
+        "server error", response=response
+    )
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="server error"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_uses_specified_user_id(mock_redmine_class):
+    """user_id передаётся в time_entry.filter вместо текущего пользователя."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id=42)
+
+    _, kwargs = mock_redmine.time_entry.filter.call_args
+    assert kwargs["user_id"] == 42
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_resolves_user_login_to_id(mock_redmine_class):
+    """Строковый логин разрешается в числовой ID."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_user = mock.MagicMock()
+    mock_user.id = 7
+    mock_redmine.user.filter.return_value = [mock_user]
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="ivanov")
+
+    login_filter_call = mock_redmine.user.filter.call_args_list[0]
+    assert login_filter_call.kwargs == {"login": "ivanov"}
+
+    _, kwargs = mock_redmine.time_entry.filter.call_args
+    assert kwargs["user_id"] == 7
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_resolves_user_name_to_id(mock_redmine_class):
+    """Строковое имя разрешается в числовой ID, если найден ровно один пользователь."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_redmine.user.filter.side_effect = [
+        [],  # поиск по логину не дал результатов
+        [mock.MagicMock(id=9)],  # поиск по имени нашёл одного
+    ]
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="Иванов И.И.")
+
+    name_filter_call = mock_redmine.user.filter.call_args_list[1]
+    assert name_filter_call.kwargs == {"name": "Иванов И.И."}
+
+    _, kwargs = mock_redmine.time_entry.filter.call_args
+    assert kwargs["user_id"] == 9
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_rejects_ambiguous_user_name(mock_redmine_class):
+    """Если по имени найдено несколько пользователей — ошибка с понятным сообщением."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_redmine.user.filter.side_effect = [
+        [],  # поиск по логину не дал результатов
+        [mock.MagicMock(id=1), mock.MagicMock(id=2)],  # по имени — несколько
+    ]
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="Multiple users match"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="Иванов")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_rejects_unknown_user_login(mock_redmine_class):
+    """Если пользователь не найден — ошибка с предложением использовать --user-id."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    mock_redmine.user.filter.return_value = []
+
+    from redmine_reporter.client import RedmineAPIError
+
+    with pytest.raises(RedmineAPIError, match="not found"):
+        fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="unknown")
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_numeric_string_user_id(mock_redmine_class):
+    """Строка из цифр интерпретируется как числовой ID."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    fetch_issues_with_spent_time("2026-01-01", "2026-01-31", user_id="42")
+
+    assert mock_redmine.user.filter.call_count == 0
+    _, kwargs = mock_redmine.time_entry.filter.call_args
+    assert kwargs["user_id"] == 42
+
+
 # -- #24: Таймаут и retry --