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

.gitignore

@@ -88,7 +88,7 @@ secrets.json
 
 # Just in case
 .~*
-report.odt
+# Local report outputs
-report.csv
+report.*
-report.md
+rep.*
 *.html

README.md

@@ -8,15 +8,16 @@ CLI-инструмент для генерации отчётов по зада
 
 ## Возможности
 
-- Получение time entries текущего пользователя из Redmine.
+- Получение time entries **текущего** или **указанного** пользователя из Redmine.
-- Авторизация через Redmine API token.
+- Авторизация через Redmine API token или логин/пароль.
-- Резервная авторизация через логин и пароль для обратной совместимости.
 - Группировка задач по проекту и версии.
 - Перевод статусов задач на русский язык.
-- Вывод в консоль в табличном или компактном виде.
+- Вывод в консоль (таблица / компактный вид).
-- Экспорт в ODT, CSV, Markdown и HTML.
+- Экспорт в ODT, CSV, Markdown, HTML, JSON и Excel (.xlsx).
-- Автоматическое определение месяца ODT-отчёта по конечной дате периода.
+- Excel-отчёт с merge-ячейками по проекту/версии, итогами, автошириной, автофильтром и закреплённой шапкой.
-- Настройка периода отчёта по умолчанию через `.env`.
+- Сводка по времени (`--summary`).
+- Понятные сообщения об ошибках Redmine API (401/403/5xx, таймаут, сеть).
+- Загрузка альтернативного `.env` через `--config`.
 
 ## Установка
 
@@ -29,9 +30,15 @@ pip install --upgrade pip
 pip install .
 ```
 
+Для разработки:
+
+```bash
+pip install -e ".[dev]"
+```
+
 ## Настройка
 
-Создайте файл `.env` в корне проекта. Файл не должен попадать в git.
+Создайте файл `.env` в корне проекта. Он не должен попадать в git.
 
 Рекомендуемый вариант авторизации:
 
@@ -44,18 +51,13 @@ DEFAULT_FROM_DATE=2026-01-01
 DEFAULT_TO_DATE=2026-01-31
 ```
 
-Если задан `REDMINE_API_KEY`, он используется в первую очередь.
+Резервный вариант:
-
-Резервный вариант авторизации:
 
 ```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
 ```
 
 Переменные окружения:
@@ -67,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_FROM_DATE` | Нет | Начальная дата периода по умолчанию (`YYYY-MM-DD`). |
-| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию в формате `YYYY-MM-DD`. |
+| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию (`YYYY-MM-DD`). |
-| `REDMINE_VERIFY` | Нет | Настройка TLS-проверки для Redmine API. |
+| `REDMINE_VERIFY` | Нет | TLS-проверка: `true` / `false` / путь к CA bundle. |
-
-`REDMINE_VERIFY` поддерживает значения:
-
-- пустое значение или отсутствие переменной: `/etc/ssl/certs/ca-certificates.crt`;
-- `true`, `1`, `yes`, `on`: стандартная проверка сертификатов `requests`;
-- `false`, `0`, `no`, `off`: отключить проверку сертификатов;
-- любой другой текст: путь к CA bundle.
-
-Отключать проверку сертификатов не рекомендуется.
 
 ## Использование
 
@@ -98,7 +91,27 @@ redmine-reporter
 redmine-reporter --date 2026-02-01--2026-02-28
 ```
 
-Период должен быть задан в формате `YYYY-MM-DD--YYYY-MM-DD`. Начальная дата не может быть позже конечной.
+Отчёт по другому пользователю:
+
+```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
+```
 
 Компактный вывод:
 
@@ -106,6 +119,12 @@ redmine-reporter --date 2026-02-01--2026-02-28
 redmine-reporter --compact
 ```
 
+Отладочный вывод:
+
+```bash
+redmine-reporter --debug
+```
+
 Экспорт:
 
 ```bash
@@ -113,35 +132,44 @@ redmine-reporter --output report.odt
 redmine-reporter --output report.csv
 redmine-reporter --output report.md
 redmine-reporter --output report.html
+redmine-reporter --output report.json
+redmine-reporter --output report.xlsx
 ```
 
-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
+black --check redmine_reporter tests
-isort 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.5.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" }]
@@ -23,6 +23,7 @@ dependencies = [
     "tabulate>=0.9.0",
     "python-dotenv>=1.0.0",
     "odfpy>=1.4.0",
+    "openpyxl>=3.1.0",
 ]
 
 [project.optional-dependencies]
@@ -56,5 +57,5 @@ multi_line_output = 3
 warn_unused_configs = true
 
 [[tool.mypy.overrides]]
-module = ["odf.*", "redminelib.*", "tabulate"]
+module = ["odf.*", "redminelib.*", "tabulate", "openpyxl.*"]
 ignore_missing_imports = true

redmine_reporter/__init__.py

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

redmine_reporter/cli.py

@@ -1,22 +1,22 @@
 import argparse
+import logging
 import os
 import re
 import sys
 from datetime import datetime
 from typing import List, Optional
 
-from .client import fetch_issues_with_spent_time
+from . import __version__
+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
+from .report_builder import build_grouped_report, calculate_summary
 
 
 def parse_date_range(date_arg: str) -> tuple[str, str]:
     if "--" not in date_arg:
         raise ValueError("Date range must be in format YYYY-MM-DD--YYYY-MM-DD")
     parts = date_arg.split("--", 1)
-    if len(parts) != 2:
-        raise ValueError("Invalid date range format")
 
     from_date, to_date = parts[0].strip(), parts[1].strip()
     date_pattern = r"\d{4}-\d{2}-\d{2}"
@@ -43,8 +43,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     parser.add_argument(
         "--date",
         default=Config.get_default_date_range(),
-        # help="Date range in format YYYY-MM-DD--YYYY-MM-DD (default: %(default)s)"
+        help="Date range in format YYYY-MM-DD--YYYY-MM-DD (default: current month or from .env)",
-        help="Date range in format YYYY-MM-DD--YYYY-MM-DD (default from .env or %(default)s)",
     )
     parser.add_argument(
         "--compact",
@@ -53,7 +52,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     )
     parser.add_argument(
         "--output",
-        help="Path to output file (.odt, .csv, .md, .html). If omitted, prints to stdout.",
+        help="Path to output file (.odt, .csv, .md, .html, .json, .xlsx). If omitted, prints to stdout.",
     )
     parser.add_argument(
         "--author", default="", help="Override author name from .env (REDMINE_AUTHOR)"
@@ -61,8 +60,59 @@ def main(argv: Optional[List[str]] = None) -> int:
     parser.add_argument(
         "--no-time", action="store_true", help="Do not include spent time into table"
     )
+    parser.add_argument("--url", help="Override Redmine URL from .env (REDMINE_URL)")
+    parser.add_argument("--api-key", help="Override Redmine API key from .env (REDMINE_API_KEY)")
+    parser.add_argument("--config", help="Path to .env config file")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument("--debug", action="store_true", help="Enable debug output")
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show version and exit",
+    )
+    parser.add_argument(
+        "--summary",
+        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)
+    Config.set_redmine_url(args.url)
+    Config.set_redmine_api_key(args.api_key)
+
+    # Настройка уровня логирования
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG, format="%(levelname)s: %(message)s")
+    elif args.verbose:
+        logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+    else:
+        logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
+
     try:
         Config.validate()
     except ValueError as e:
@@ -76,25 +126,46 @@ 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:
         print("ℹ️  No time entries found in the given period.", file=sys.stderr)
         return 0
 
-    print(f"✅ Total issues: {len(issue_hours)} [{args.date}]")
+    if not issue_hours:
+        print("ℹ️  No time entries found in the given period.", file=sys.stderr)
+        return 0
+
+    print(f"✅ Total issues: {len(issue_hours)} [{args.date}]", file=sys.stderr)
 
     rows = build_grouped_report(issue_hours, fill_time=not args.no_time)
 
+    if args.summary:
+        summary = calculate_summary(rows)
+        print(f"⏱️  Total time: {summary['total']}h", file=sys.stderr)
+        for key, value in summary.items():
+            if key.startswith("project:"):
+                project = key.split(":", 1)[1]
+                print(f"   {project}: {value}h", file=sys.stderr)
+
     if args.output:
         output_ext = os.path.splitext(args.output)[1].lower()
 
         if not output_ext:
             print(
-                "❌ Файл без расширения. Укажите расширение: .odt, .csv, .md или .html",
+                "❌ Файл без расширения. Укажите расширение: .odt, .csv, .md, .html, .json или .xlsx",
                 file=sys.stderr,
             )
             return 1
@@ -104,28 +175,27 @@ def main(argv: Optional[List[str]] = None) -> int:
             author=Config.get_author(args.author),
             from_date=from_date,
             to_date=to_date,
+            no_time=args.no_time,
         )
 
         if not formatter:
-            known_exts = ", ".join([".odt", ".csv", ".md", ".html"])
-            print(
-                f"❌ Неизвестный формат файла: {output_ext!r}. Поддерживаются: {known_exts}",
-                file=sys.stderr,
-            )
-            return 1
-
-        try:
-            formatter.save(rows, args.output)
-            print(f"✅ Report saved to {args.output}")
-        except ImportError as e:
             if output_ext == ".odt":
                 print(
                     "❌ odfpy is not installed. Install with: pip install odfpy",
                     file=sys.stderr,
                 )
             else:
-                print(f"❌ Import error: {e}", file=sys.stderr)
+                known_exts = ", ".join([".odt", ".csv", ".md", ".html", ".json", ".xlsx"])
+                print(
+                    f"❌ Неизвестный формат файла: {output_ext!r}. "
+                    f"Поддерживаются: {known_exts}",
+                    file=sys.stderr,
+                )
             return 1
+
+        try:
+            formatter.save(rows, args.output)
+            print(f"✅ Report saved to {args.output}")
         except Exception as e:
             fmt = output_ext.lstrip(".").upper()
             print(f"❌ {fmt} export error: {e}", file=sys.stderr)

redmine_reporter/client.py

@@ -1,10 +1,27 @@
-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
 
 from .config import Config
-from .utils import get_version
+
+# Таймаут на один HTTP-запрос к Redmine (секунды).
+REQUEST_TIMEOUT = 30
+
+# Размер чанка для запроса задач по issue_id, чтобы не превышать лимит длины URL (#21).
+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]:
@@ -18,26 +35,181 @@ def _get_redmine_auth_kwargs() -> Dict[str, Any]:
     }
 
 
-def fetch_issues_with_spent_time(
+def _make_retry_adapter() -> requests.adapters.HTTPAdapter:
-    from_date: str, to_date: str
+    """Создаёт HTTPAdapter с retry для временных ошибок (#24)."""
-) -> Optional[List[Tuple[Issue, float]]]:
+    retry = Retry(
-    """
+        total=3,
-    Fetch unique issues linked to time entries of the current user in given date range,
+        backoff_factor=0.5,
-    along with total spent hours per issue.
+        status_forcelist=[429, 500, 502, 503, 504],
-    Returns list of (issue, total_hours) tuples.
+        allowed_methods=["GET", "HEAD", "OPTIONS"],
-    """
+    )
+    return requests.adapters.HTTPAdapter(max_retries=retry)
 
+
+def _create_redmine() -> Redmine:
+    """Создаёт Redmine-клиент с таймаутом и retry-адаптером (#24)."""
     redmine = Redmine(
         Config.get_redmine_url(),
         **_get_redmine_auth_kwargs(),
-        requests={"verify": Config.get_redmine_verify()},
+        requests={
+            "verify": Config.get_redmine_verify(),
+            "timeout": REQUEST_TIMEOUT,
+        },
     )
 
-    current_user = redmine.user.get("current")
+    # Монтируем retry-адаптер на сессию для автоматических повторов.
-    time_entries = redmine.time_entry.filter(
+    # В python-redmine сессия живёт в engine, а redmine.session — контекстный менеджер.
-        user_id=current_user.id, from_date=from_date, to_date=to_date
+    retry_adapter = _make_retry_adapter()
+    redmine.engine.session.mount("https://", retry_adapter)
+    redmine.engine.session.mount("http://", retry_adapter)
+
+    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] = []
+    for i in range(0, len(issue_ids), ISSUE_ID_CHUNK_SIZE):
+        chunk = issue_ids[i : i + ISSUE_ID_CHUNK_SIZE]
+        issue_list_str = ",".join(str(x) for x in chunk)
+        issues = redmine.issue.filter(issue_id=issue_list_str, status_id="*", sort="project:asc")
+        all_issues.extend(issues)
+    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,
+    user_id: Optional[Union[int, str]] = None,
+) -> Optional[List[Tuple[Issue, float]]]:
+    """
+    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()
+        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] = {}
     issue_ids = set()
@@ -50,17 +222,19 @@ def fetch_issues_with_spent_time(
     if not issue_ids:
         return None
 
-    # Загружаем полные объекты задач
+    # Загружаем полные объекты задач чанками (#21)
-    issue_list_str = ",".join(str(i) for i in issue_ids)
+    try:
-    issues = redmine.issue.filter(issue_id=issue_list_str, status_id="*", sort="project:asc")
+        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,
+    # здесь оставляем порядок API как есть.
     result = []
     for issue in issues:
         total_hours = spent_time.get(issue.id, 0.0)
         result.append((issue, total_hours))
 
-    # Сортируем по (проект, версия)
-    result.sort(key=lambda x: (str(x[0].project), get_version(x[0])))
-
     return result

redmine_reporter/config.py

@@ -1,9 +1,10 @@
 import os
+from datetime import date, timedelta
 from typing import Union
 
 from dotenv import load_dotenv
 
-load_dotenv()
+load_dotenv(override=False)
 
 DEFAULT_REDMINE_VERIFY = "/etc/ssl/certs/ca-certificates.crt"
 FALSE_VALUES = {"0", "false", "no", "off"}
@@ -11,12 +12,32 @@ TRUE_VALUES = {"1", "true", "yes", "on"}
 
 
 class Config:
+    _cli_url: str | None = None
+    _cli_api_key: str | None = None
+
+    @classmethod
+    def load_config(cls, path: str) -> None:
+        """Загружает переменные из указанного .env-файла с override."""
+        load_dotenv(path, override=True)
+
+    @classmethod
+    def set_redmine_url(cls, url: str) -> None:
+        cls._cli_url = url.strip().rstrip("/") if url else None
+
+    @classmethod
+    def set_redmine_api_key(cls, key: str) -> None:
+        cls._cli_api_key = key.strip() if key else None
+
     @classmethod
     def get_redmine_url(cls) -> str:
+        if cls._cli_url is not None:
+            return cls._cli_url
         return os.getenv("REDMINE_URL", "").strip().rstrip("/")
 
     @classmethod
     def get_redmine_api_key(cls) -> str:
+        if cls._cli_api_key is not None:
+            return cls._cli_api_key
         return os.getenv("REDMINE_API_KEY", "").strip()
 
     @classmethod
@@ -25,7 +46,7 @@ class Config:
 
     @classmethod
     def get_redmine_password(cls) -> str:
-        return os.getenv("REDMINE_PASSWORD", "")
+        return os.getenv("REDMINE_PASSWORD", "").strip()
 
     @classmethod
     def get_redmine_verify(cls) -> Union[bool, str]:
@@ -53,8 +74,17 @@ class Config:
         default_to_date = os.getenv("DEFAULT_TO_DATE", "").strip()
         if default_from_date and default_to_date:
             return f"{default_from_date}--{default_to_date}"
-        # fallback hardcoded
+
-        return "2025-12-19--2026-01-31"
+        # fallback: текущий месяц
+        today = date.today()
+        start = today.replace(day=1)
+        # последний день месяца: берём первое число следующего месяца и вычитаем день
+        if today.month == 12:
+            next_month = today.replace(year=today.year + 1, month=1, day=1)
+        else:
+            next_month = today.replace(month=today.month + 1, day=1)
+        end = next_month - timedelta(days=1)
+        return f"{start.isoformat()}--{end.isoformat()}"
 
     @classmethod
     def validate(cls) -> None:

redmine_reporter/formatters/csv.py

@@ -7,29 +7,39 @@ from .base import Formatter
 
 
 class CSVFormatter(Formatter):
-    """Форматтер для экспорта в CSV."""
+    """Форматтер для экспорта в CSV.
 
-    def __init__(self, **_kwargs):
+    Использует полные значения project/version (а не display-значения с пустыми
+    ячейками для групп). Каждая строка CSV самодостаточна — это корректно для
+    табличного формата (#31). Файл сохраняется в UTF-8 с BOM (utf-8-sig) для
+    корректного отображения кириллицы в Microsoft Excel (#26).
+    """
+
+    def __init__(self, no_time: bool = False, **_kwargs):
         super().__init__()
+        self.no_time = no_time
 
     def format(self, rows: List[ReportRow]) -> str:
         output = io.StringIO()
         writer = csv.writer(output, dialect="excel")
-        writer.writerow(["Project", "Version", "Issue ID", "Subject", "Status", "Spent Time"])
+        headers = ["Project", "Version", "Issue ID", "Subject", "Status"]
+        if not self.no_time:
+            headers.append("Spent Time")
+        writer.writerow(headers)
         for r in rows:
-            writer.writerow(
+            data = [
-                [
+                r["project"],
-                    r["project"],
+                r["version"],
-                    r["version"],
+                r["issue_id"],
-                    r["issue_id"],
+                r["subject"],
-                    r["subject"],
+                r["status_ru"],
-                    r["status_ru"],
+            ]
-                    r["time_text"],
+            if not self.no_time:
-                ]
+                data.append(r["time_text"])
-            )
+            writer.writerow(data)
         return output.getvalue()
 
     def save(self, rows: List[ReportRow], output_path: str) -> None:
         content = self.format(rows)
-        with open(output_path, "w", encoding="utf-8", newline="") as f:
+        with open(output_path, "w", encoding="utf-8-sig", newline="") as f:
             f.write(content)

redmine_reporter/formatters/factory.py

@@ -4,15 +4,19 @@ from .base import Formatter
 from .console import CompactFormatter, TableFormatter
 from .csv import CSVFormatter
 from .html import HTMLFormatter
+from .json import JSONFormatter
 from .markdown import MarkdownFormatter
-from .odt import ODTFormatter
+from .xlsx import XLSXFormatter
 
-# Словарь для сопоставления расширений файлов с классами форматтеров
+# Словарь для сопоставления расширений файлов с классами форматтеров.
+# ODT и XLSX намеренно отсутствуют — их импорт отложен (ленивый), так как
+# odfpy/openpyxl может быть не установлен. См. get_formatter_by_extension.
 FORMATTER_MAP: Dict[str, Type[Formatter]] = {
-    ".odt": ODTFormatter,
     ".csv": CSVFormatter,
+    ".json": JSONFormatter,
     ".md": MarkdownFormatter,
     ".html": HTMLFormatter,
+    ".xlsx": XLSXFormatter,
 }
 
 
@@ -27,10 +31,23 @@ def get_formatter_by_extension(extension: str, **kwargs) -> Optional[Formatter]:
     """
     Возвращает экземпляр форматтера по расширению файла.
     Ключевые аргументы (**kwargs) передаются в конструктор форматтера.
+    Возвращает None для .odt, если odfpy не установлен.
     """
-    formatter_class = FORMATTER_MAP.get(extension.lower())
+    ext = extension.lower()
+
+    formatter_class = FORMATTER_MAP.get(ext)
     if formatter_class:
         return formatter_class(**kwargs)
+
+    # ODT требует odfpy — ленивый импорт, чтобы отсутствие зависимости
+    # не ломало загрузку модуля и другие форматтеры.
+    if ext == ".odt":
+        try:
+            from .odt import ODTFormatter
+        except ImportError:
+            return None
+        return ODTFormatter(**kwargs)
+
     return None
 
 

redmine_reporter/formatters/html.py

@@ -1,6 +1,7 @@
 from html import escape
-from typing import Dict, List
+from typing import List
 
+from ..report_builder import group_rows_by_project_and_version
 from ..types import ReportRow
 from .base import Formatter
 
@@ -12,18 +13,15 @@ class HTMLFormatter(Formatter):
         super().__init__()
 
     def format(self, rows: List[ReportRow]) -> str:
-        # Сгруппируем данные
+        projects = group_rows_by_project_and_version(rows)
-        projects: Dict[str, Dict[str, List[ReportRow]]] = {}
-        for r in rows:
-            proj = r["project"]
-            ver = r["version"]
-            if proj not in projects:
-                projects[proj] = {}
-            if ver not in projects[proj]:
-                projects[proj][ver] = []
-            projects[proj][ver].append(r)
 
         lines = [
+            "<!DOCTYPE html>",
+            '<html lang="ru">',
+            "<head>",
+            '  <meta charset="utf-8">',
+            "</head>",
+            "<body>",
             '<table border="1" cellpadding="6" cellspacing="0" style="border-collapse: collapse; font-family: Arial, sans-serif;">',
             "  <thead>",
             "    <tr>",
@@ -77,6 +75,8 @@ class HTMLFormatter(Formatter):
 
         lines.append("  </tbody>")
         lines.append("</table>")
+        lines.append("</body>")
+        lines.append("</html>")
         return "\n".join(lines)
 
     def save(self, rows: List[ReportRow], output_path: str) -> None:

redmine_reporter/formatters/json.py

@@ -0,0 +1,31 @@
+import json
+from typing import List
+
+from ..types import ReportRow
+from .base import Formatter
+
+
+class JSONFormatter(Formatter):
+    """Форматтер для экспорта отчёта в JSON."""
+
+    def __init__(self, **_kwargs):
+        super().__init__()
+
+    def format(self, rows: List[ReportRow]) -> str:
+        data = [
+            {
+                "project": r["project"],
+                "version": r["version"],
+                "issue_id": r["issue_id"],
+                "subject": r["subject"],
+                "status": r["status_ru"],
+                "time": r["time_text"],
+            }
+            for r in rows
+        ]
+        return json.dumps(data, ensure_ascii=False, indent=2)
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        content = self.format(rows)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(content)

redmine_reporter/formatters/odt.py

@@ -1,11 +1,12 @@
 from importlib import resources
-from typing import Dict, List
+from typing import List
 
 from odf.opendocument import OpenDocument, load
 from odf.style import Style, TableCellProperties, TableColumnProperties
-from odf.table import Table, TableCell, TableColumn, TableRow
+from odf.table import CoveredTableCell, Table, TableCell, TableColumn, TableRow
 from odf.text import P
 
+from ..report_builder import group_rows_by_project_and_version
 from ..types import ReportRow
 from ..utils import get_month_name_from_range
 from .base import Formatter
@@ -14,7 +15,7 @@ from .base import Formatter
 class ODTFormatter(Formatter):
     """Форматтер для экспорта в ODT."""
 
-    def __init__(self, author: str = "", from_date: str = "", to_date: str = ""):
+    def __init__(self, author: str = "", from_date: str = "", to_date: str = "", **_kwargs):
         """
         Инициализирует форматтер с параметрами для шапки отчета.
         """
@@ -34,7 +35,10 @@ class ODTFormatter(Formatter):
 
         # Заголовок
         month_name = get_month_name_from_range(self.from_date, self.to_date)
-        header_text = f"{self.author}. Отчет за месяц {month_name}."
+        if self.author:
+            header_text = f"{self.author}. Отчет за месяц {month_name}."
+        else:
+            header_text = f"Отчет за месяц {month_name}."
         doc.text.addElement(P(stylename=para_style_name, text=header_text))
         doc.text.addElement(P(stylename=para_style_name, text=""))
 
@@ -69,18 +73,7 @@ class ODTFormatter(Formatter):
             header_row.addElement(cell)
         table.addElement(header_row)
 
-        projects: Dict[str, Dict[str, List[ReportRow]]] = {}
+        projects = group_rows_by_project_and_version(rows)
-        for r in rows:
-            project = r["project"]
-            version = r["version"]
-
-            if project not in projects:
-                projects[project] = {}
-
-            if version not in projects[project]:
-                projects[project][version] = []
-
-            projects[project][version].append(r)
 
         # Данные с двухуровневой группировкой и объединением ячеек
         for project, versions in projects.items():
@@ -96,15 +89,19 @@ class ODTFormatter(Formatter):
                 for r in rows_for_version:
                     row = TableRow()
 
-                    # Ячейка "Проект" - только в первой строке всего проекта
+                    # Ячейка "Проект" - только в первой строке всего проекта,
+                    # в остальных — covered-cell для валидности ODF (#13)
                     if first_version_in_project and first_row_in_version:
                         cell_project = TableCell(stylename=cell_style_name)
                         cell_project.setAttribute("numberrowsspanned", str(total_project_rows))
                         p = P(stylename=para_style_name, text=project)
                         cell_project.addElement(p)
                         row.addElement(cell_project)
+                    else:
+                        row.addElement(CoveredTableCell())
 
-                    # Ячейка "Версия" - только в первой строке каждой версии
+                    # Ячейка "Версия" - только в первой строке каждой версии,
+                    # в остальных — covered-cell для валидности ODF (#13)
                     if first_row_in_version:
                         cell_version = TableCell(stylename=cell_style_name)
                         cell_version.setAttribute("numberrowsspanned", str(row_span_version))
@@ -112,6 +109,8 @@ class ODTFormatter(Formatter):
                         cell_version.addElement(p)
                         row.addElement(cell_version)
                         first_row_in_version = False
+                    else:
+                        row.addElement(CoveredTableCell())
 
                     # Остальные колонки
                     task_cell = TableCell(stylename=cell_style_name)

redmine_reporter/formatters/xlsx.py

@@ -0,0 +1,214 @@
+from typing import Dict, List, Tuple
+
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.worksheet import Worksheet
+
+from ..report_builder import group_rows_by_project_and_version
+from ..types import ReportRow
+from ..utils import hours_to_human
+from .base import Formatter
+
+
+class XLSXFormatter(Formatter):
+    """Форматтер для экспорта отчёта в Excel (.xlsx).
+
+    Использует группировку по проекту и версии: объединяет ячейки,
+    добавляет итоги по группам, закрепляет заголовок, включает автофильтр
+    и числовой столбец с часами для удобного суммирования.
+    """
+
+    _HEADER_FILL = PatternFill(start_color="D9E1F2", end_color="D9E1F2", fill_type="solid")
+    _TOTAL_FILL = PatternFill(start_color="FFF2CC", end_color="FFF2CC", fill_type="solid")
+    _BORDER = Border(
+        left=Side(style="thin"),
+        right=Side(style="thin"),
+        top=Side(style="thin"),
+        bottom=Side(style="thin"),
+    )
+
+    def __init__(self, no_time: bool = False, **_kwargs):
+        super().__init__()
+        self.no_time = no_time
+
+    def format(self, rows: List[ReportRow]) -> Workbook:
+        wb = Workbook()
+        ws = wb.active
+        if ws is None:
+            ws = wb.create_sheet("Report")
+        else:
+            ws.title = "Report"
+
+        headers = ["Project", "Version", "Issue ID", "Subject", "Status", "Hours", "Spent Time"]
+        ws.append(headers)
+        self._style_header_row(ws, headers)
+
+        grouped = group_rows_by_project_and_version(rows)
+
+        current_row = 2
+        project_ranges: List[Tuple[int, int]] = []
+        version_ranges: List[Tuple[int, int]] = []
+        project_totals: Dict[str, float] = {}
+
+        for project, versions in grouped.items():
+            project_start_row = current_row
+
+            for version, task_rows in versions.items():
+                version_start_row = current_row
+
+                for r in task_rows:
+                    hours = "" if self.no_time else r.get("hours", 0.0)
+                    time_text = "" if self.no_time else r["time_text"]
+                    ws.append(
+                        [
+                            project,
+                            version,
+                            r["issue_id"],
+                            r["subject"],
+                            r["status_ru"],
+                            hours,
+                            time_text,
+                        ]
+                    )
+                    self._style_data_row(ws, current_row)
+                    current_row += 1
+
+                if not self.no_time:
+                    version_hours = sum(r.get("hours", 0.0) for r in task_rows)
+                    ws.append(
+                        [
+                            "",
+                            f"Total {version}",
+                            "",
+                            "",
+                            "",
+                            version_hours,
+                            hours_to_human(version_hours),
+                        ]
+                    )
+                    self._style_total_row(ws, current_row, bold=False)
+                    ws.merge_cells(
+                        start_row=current_row, start_column=2, end_row=current_row, end_column=5
+                    )
+                    current_row += 1
+
+                version_end_row = current_row - 1
+                if version_end_row > version_start_row:
+                    version_ranges.append((version_start_row, version_end_row))
+
+            if not self.no_time:
+                project_hours = sum(
+                    sum(r.get("hours", 0.0) for r in task_rows) for task_rows in versions.values()
+                )
+                ws.append(
+                    [
+                        f"Total {project}",
+                        "",
+                        "",
+                        "",
+                        "",
+                        project_hours,
+                        hours_to_human(project_hours),
+                    ]
+                )
+                self._style_total_row(ws, current_row, bold=True)
+                ws.merge_cells(
+                    start_row=current_row, start_column=1, end_row=current_row, end_column=5
+                )
+                current_row += 1
+                project_totals[project] = project_hours
+
+            project_end_row = current_row - 1
+            if project_end_row > project_start_row:
+                project_ranges.append((project_start_row, project_end_row))
+
+        if not self.no_time and project_totals:
+            total_hours = sum(project_totals.values())
+            ws.append(
+                [
+                    "Total",
+                    "",
+                    "",
+                    "",
+                    "",
+                    total_hours,
+                    hours_to_human(total_hours),
+                ]
+            )
+            self._style_total_row(ws, current_row, bold=True)
+            ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=5)
+
+        for start, end in project_ranges:
+            ws.merge_cells(start_row=start, start_column=1, end_row=end, end_column=1)
+            cell = ws.cell(row=start, column=1)
+            cell.alignment = Alignment(vertical="top", wrap_text=True)
+
+        for start, end in version_ranges:
+            ws.merge_cells(start_row=start, start_column=2, end_row=end, end_column=2)
+            cell = ws.cell(row=start, column=2)
+            cell.alignment = Alignment(vertical="top", wrap_text=True)
+
+        self._apply_column_widths(ws)
+        if not self.no_time:
+            self._apply_number_format(ws)
+        self._apply_auto_filter(ws, ws.max_row)
+        ws.freeze_panes = "A2"
+
+        return wb
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        wb = self.format(rows)
+        wb.save(output_path)
+
+    def _style_header_row(self, ws: Worksheet, headers: List[str]) -> None:
+        for col_idx, _ in enumerate(headers, start=1):
+            cell = ws.cell(row=1, column=col_idx)
+            cell.font = Font(bold=True)
+            cell.fill = self._HEADER_FILL
+            cell.border = self._BORDER
+            cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+
+    def _style_data_row(self, ws: Worksheet, row: int) -> None:
+        for col_idx in range(1, 8):
+            cell = ws.cell(row=row, column=col_idx)
+            cell.border = self._BORDER
+            if col_idx in (1, 2):
+                cell.alignment = Alignment(vertical="top", wrap_text=True)
+            elif col_idx == 4:
+                cell.alignment = Alignment(vertical="top", wrap_text=True)
+            else:
+                cell.alignment = Alignment(vertical="top")
+
+    def _style_total_row(self, ws: Worksheet, row: int, bold: bool) -> None:
+        for col_idx in range(1, 8):
+            cell = ws.cell(row=row, column=col_idx)
+            cell.border = self._BORDER
+            cell.fill = self._TOTAL_FILL
+            cell.font = Font(bold=bold)
+            cell.alignment = Alignment(vertical="center")
+
+    def _apply_column_widths(self, ws: Worksheet) -> None:
+        # Минимальные ширины по умолчанию
+        widths: Dict[int, float] = {1: 18.0, 2: 16.0, 3: 12.0, 4: 45.0, 5: 14.0, 6: 10.0, 7: 14.0}
+
+        for row in ws.iter_rows(min_row=2, max_row=ws.max_row):
+            for col_idx, cell in enumerate(row, start=1):
+                if cell.value is None:
+                    continue
+                text = str(cell.value)
+                # Оценочная ширина: примерно 1.1 символа на единицу ширины Excel
+                estimated = len(text) * 1.1 + 2
+                widths[col_idx] = max(widths[col_idx], min(estimated, 80))
+
+        for col_idx, width in widths.items():
+            ws.column_dimensions[get_column_letter(col_idx)].width = width
+
+    def _apply_number_format(self, ws: Worksheet) -> None:
+        for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=6, max_col=6):
+            for cell in row:
+                if isinstance(cell.value, (int, float)):
+                    cell.number_format = "0.00"
+
+    def _apply_auto_filter(self, ws: Worksheet, max_row: int) -> None:
+        ws.auto_filter.ref = f"A1:G{max_row}"

redmine_reporter/report_builder.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, cast
+from typing import Dict, List, Tuple, cast
 
 from redminelib.resources import Issue
 
@@ -35,7 +35,7 @@ def build_grouped_report(
     """
 
     # Защитная сортировка -- гарантирует корректную группировку независимо от порядка на входе
-    issue_hours = sorted(issue_hours, key=lambda x: (str(x[0].project), get_version(x[0])))
+    issue_hours = sorted(issue_hours, key=lambda x: (str(x[0].project), get_version(x[0]), x[0].id))
 
     rows: List[ReportRow] = []
     prev_project: str = ""
@@ -63,6 +63,7 @@ def build_grouped_report(
                     "subject": issue.subject,
                     "status_ru": status_ru,
                     "time_text": time_text,
+                    "hours": round(hours, 2),
                 },
             )
         )
@@ -71,3 +72,48 @@ def build_grouped_report(
         prev_version = version
 
     return rows
+
+
+def calculate_summary(rows: List[ReportRow]) -> Dict[str, float]:
+    """Возвращает сводку: общее время, время по проектам и версиям."""
+    total = 0.0
+    by_project: Dict[str, float] = {}
+    by_project_version: Dict[str, float] = {}
+
+    for r in rows:
+        hours = r.get("hours", 0.0)
+        total += hours
+        by_project[r["project"]] = by_project.get(r["project"], 0.0) + hours
+        key = f"{r['project']}::{r['version']}"
+        by_project_version[key] = by_project_version.get(key, 0.0) + hours
+
+    return {
+        "total": round(total, 2),
+        **{f"project:{k}": round(v, 2) for k, v in by_project.items()},
+        **{f"version:{k}": round(v, 2) for k, v in by_project_version.items()},
+    }
+
+
+def group_rows_by_project_and_version(
+    rows: List[ReportRow],
+) -> Dict[str, Dict[str, List[ReportRow]]]:
+    """
+    Группирует плоский список строк отчёта в иерархию project → version → [rows].
+
+    Предполагается, что rows уже отсортирован (build_grouped_report это гарантирует).
+    Возвращает обычный dict, сохраняющий порядок вставки (Python 3.7+).
+    Используется форматтерами HTML и ODT для объединения ячеек.
+    """
+    projects: Dict[str, Dict[str, List[ReportRow]]] = {}
+    for r in rows:
+        project = r["project"]
+        version = r["version"]
+
+        if project not in projects:
+            projects[project] = {}
+        if version not in projects[project]:
+            projects[project][version] = []
+
+        projects[project][version].append(r)
+
+    return projects

redmine_reporter/types.py

@@ -12,3 +12,4 @@ class ReportRow(TypedDict):
     subject: str
     status_ru: str
     time_text: str
+    hours: float

redmine_reporter/utils.py

@@ -33,7 +33,8 @@ def get_version(issue) -> str:
     version = getattr(issue, "fixed_version", None)
     if version is None:
         return "<N/A>"
-    return str(version)
+    name = getattr(version, "name", None)
+    return str(name) if name else str(version)
 
 
 def hours_to_human(hours: float) -> str:

tests/test_cli.py

@@ -1,6 +1,4 @@
 import os
-import sys
-from io import StringIO
 from unittest import mock
 
 import pytest
@@ -13,6 +11,18 @@ VALID_ENV = {
 }
 
 
+@pytest.fixture(autouse=True)
+def _reset_config_overrides():
+    """Сбрасывает CLI-переопределения Config перед каждым тестом."""
+    from redmine_reporter.config import Config
+
+    Config.set_redmine_url("")
+    Config.set_redmine_api_key("")
+    yield
+    Config.set_redmine_url("")
+    Config.set_redmine_api_key("")
+
+
 @pytest.mark.parametrize(
     "date_arg, expected",
     [
@@ -38,21 +48,6 @@ def test_parse_date_range_invalid(date_arg):
         parse_date_range(date_arg)
 
 
-@mock.patch.dict(os.environ, VALID_ENV, clear=True)
-@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
-def test_cli_smoke_empty(mock_fetch):
-    """Пустой список задач -- выход 0, сообщение о 0 задачах."""
-    mock_fetch.return_value = []
-    captured = StringIO()
-    old_stdout, sys.stdout = sys.stdout, captured
-    try:
-        code = main(["--date", "2026-01-01--2026-01-31"])
-    finally:
-        sys.stdout = old_stdout
-    assert code == 0
-    assert "Total issues: 0" in captured.getvalue()
-
-
 @mock.patch.dict(os.environ, VALID_ENV, clear=True)
 @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
 def test_cli_returns_zero_on_no_entries(mock_fetch):
@@ -76,11 +71,23 @@ def test_cli_invalid_date_format():
     assert code == 1
 
 
+class _MockIssue:
+    """Простой mock Redmine Issue для CLI-тестов."""
+
+    def __init__(self, issue_id=1, subject="Task", project="Project", status="New"):
+        self.id = issue_id
+        self.subject = subject
+        self.project = project
+        self.status = status
+        self.fixed_version = None
+
+
 @mock.patch.dict(os.environ, VALID_ENV, clear=True)
 @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
 def test_cli_unknown_output_extension(mock_fetch, tmp_path):
     """Неизвестное расширение файла -- выход 1."""
-    mock_fetch.return_value = []
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
     output = str(tmp_path / "report.xyz")
     code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
     assert code == 1
@@ -90,7 +97,207 @@ def test_cli_unknown_output_extension(mock_fetch, tmp_path):
 @mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
 def test_cli_output_without_extension(mock_fetch, tmp_path):
     """Файл без расширения -- выход 1 с подсказкой."""
-    mock_fetch.return_value = []
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
     output = str(tmp_path / "report")
     code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
     assert code == 1
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+@mock.patch("redmine_reporter.cli.get_formatter_by_extension")
+def test_cli_odt_missing_odfpy_message(mock_gf, mock_fetch, tmp_path, capsys):
+    """При запросе .odt без odfpy — выход 1, понятное сообщение про odfpy."""
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
+    mock_gf.return_value = None
+    output = str(tmp_path / "report.odt")
+    code = main(["--date", "2026-01-01--2026-01-31", "--output", output])
+    assert code == 1
+    captured = capsys.readouterr()
+    assert "odfpy" in captured.err
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+def test_cli_version_flag(capsys):
+    """--version выводит версию и завершается с 0."""
+    with pytest.raises(SystemExit) as exc_info:
+        main(["--version"])
+    assert exc_info.value.code == 0
+    captured = capsys.readouterr()
+    assert "redmine-reporter" in captured.out
+    from redmine_reporter import __version__
+
+    assert __version__ in captured.out
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_verbose_and_debug_flags_accepted(mock_fetch):
+    """--verbose и --debug не ломают запуск."""
+    mock_fetch.return_value = None
+    code = main(["--date", "2026-01-01--2026-01-31", "--verbose"])
+    assert code == 0
+    code = main(["--date", "2026-01-01--2026-01-31", "--debug"])
+    assert code == 0
+
+
+class _MockIssue:
+    """Простой mock Redmine Issue для CLI-тестов."""
+
+    def __init__(self, issue_id=1, subject="Task", project="Project", status="New"):
+        self.id = issue_id
+        self.subject = subject
+        self.project = project
+        self.status = status
+        self.fixed_version = None
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_url_and_api_key_override_env(mock_fetch):
+    """--url и --api-key переопределяют отсутствующие/другие env-переменные."""
+    mock_fetch.return_value = None
+    code = main(
+        [
+            "--date",
+            "2026-01-01--2026-01-31",
+            "--url",
+            "https://other.redmine.loc",
+            "--api-key",
+            "cli-token",
+        ]
+    )
+    assert code == 0
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_config_file_loading(mock_fetch, tmp_path):
+    """--config загружает переменные из указанного .env-файла."""
+    config_path = tmp_path / "custom.env"
+    config_path.write_text(
+        "REDMINE_URL=https://config.redmine.loc\n" "REDMINE_API_KEY=config-token\n",
+        encoding="utf-8",
+    )
+    mock_fetch.return_value = None
+    code = main(["--date", "2026-01-01--2026-01-31", "--config", str(config_path)])
+    assert code == 0
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_summary_flag_prints_totals(mock_fetch, capsys):
+    """--summary выводит общее время и разбивку по проектам в stderr."""
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
+    main(["--date", "2026-01-01--2026-01-31", "--summary"])
+    captured = capsys.readouterr()
+    assert "Total time" in captured.err
+    assert "Project" in captured.err or "Project" in captured.out
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_total_issues_message_goes_to_stderr(mock_fetch, capsys):
+    """«Total issues» пишется в stderr, не загрязняя stdout при pipe (#28)."""
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
+    main(["--date", "2026-01-01--2026-01-31"])
+    captured = capsys.readouterr()
+    assert "Total issues" not in captured.out
+    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):
+    """CLI --no-time передаётся в файловый форматтер."""
+    issue = _MockIssue()
+    mock_fetch.return_value = [(issue, 1.0)]
+
+    output = str(tmp_path / "report.xlsx")
+    with mock.patch("redmine_reporter.cli.get_formatter_by_extension") as mock_get_formatter:
+        mock_formatter = mock.MagicMock()
+        mock_get_formatter.return_value = mock_formatter
+        main(["--date", "2026-01-01--2026-01-31", "--output", output, "--no-time"])
+
+    _, 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
 
@@ -133,7 +135,7 @@ def test_fetch_uses_api_key_when_present(mock_redmine_class):
 
     _, kwargs = mock_redmine_class.call_args
     assert kwargs["key"] == "api-token"
-    assert kwargs["requests"] == {"verify": DEFAULT_REDMINE_VERIFY}
+    assert kwargs["requests"]["verify"] == DEFAULT_REDMINE_VERIFY
     assert "username" not in kwargs
     assert "password" not in kwargs
 
@@ -151,7 +153,7 @@ def test_fetch_uses_username_password_when_no_api_key(mock_redmine_class):
     _, kwargs = mock_redmine_class.call_args
     assert kwargs["username"] == "user"
     assert kwargs["password"] == "password"
-    assert kwargs["requests"] == {"verify": DEFAULT_REDMINE_VERIFY}
+    assert kwargs["requests"]["verify"] == DEFAULT_REDMINE_VERIFY
     assert "key" not in kwargs
 
 
@@ -165,4 +167,271 @@ def test_fetch_uses_custom_verify_path(mock_redmine_class):
     fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
 
     _, kwargs = mock_redmine_class.call_args
-    assert kwargs["requests"] == {"verify": "/tmp/redmine-ca.pem"}
+    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 --
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_sets_timeout_in_requests(mock_redmine_class):
+    """В requests dict передаётся timeout (#24)."""
+    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")
+
+    _, kwargs = mock_redmine_class.call_args
+    assert "timeout" in kwargs["requests"]
+    assert kwargs["requests"]["timeout"] == 30
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_mounts_retry_adapter(mock_redmine_class):
+    """На сессию монтируется HTTPAdapter с retry для временных ошибок (#24)."""
+    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")
+
+    # Проверяем, что engine.session.mount был вызван для http:// и https://
+    mount_calls = mock_redmine.engine.session.mount.call_args_list
+    prefixes = [call.args[0] for call in mount_calls]
+    assert "https://" in prefixes
+    assert "http://" in prefixes
+
+    # Проверяем retry-конфигурацию адаптера
+    https_adapter = next(call.args[1] for call in mount_calls if call.args[0] == "https://")
+    max_retries = https_adapter.max_retries
+    assert max_retries.total == 3
+    assert 429 in max_retries.status_forcelist
+
+
+# -- #21: Чанкирование issue_ids --
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_chunks_large_issue_count(mock_redmine_class):
+    """При >100 задач запросы разбиваются на чанки (#21)."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    # 250 time entries → 250 уникальных issue_id
+    entries = []
+    for i in range(1, 251):
+        e = mock.MagicMock()
+        e.issue.id = i
+        e.hours = 1.0
+        entries.append(e)
+    mock_redmine.time_entry.filter.return_value = entries
+
+    # issue.filter вызывается с чанками по 100 ID
+    call_chunks = []
+
+    def issue_filter_side_effect(**kwargs):
+        ids_str = kwargs.get("issue_id", "")
+        call_chunks.append(ids_str)
+        ids = [int(x) for x in ids_str.split(",")]
+        return [mock.MagicMock(id=i, project="P", subject="T", status="New") for i in ids]
+
+    mock_redmine.issue.filter.side_effect = issue_filter_side_effect
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    # Должно быть 3 вызова (100 + 100 + 50)
+    assert len(call_chunks) == 3
+    assert len(call_chunks[0].split(",")) == 100
+    assert len(call_chunks[1].split(",")) == 100
+    assert len(call_chunks[2].split(",")) == 50
+    assert result is not None
+    assert len(result) == 250

tests/test_config.py

@@ -74,9 +74,19 @@ def test_get_default_date_range_from_env():
 
 @mock.patch.dict(os.environ, {}, clear=True)
 def test_get_default_date_range_fallback():
-    """Если даты не заданы -- используется хардкод-заглушка."""
+    """Если даты не заданы -- используется текущий месяц."""
+    from datetime import date, timedelta
+
+    today = date.today()
+    start = today.replace(day=1)
+    if today.month == 12:
+        next_month = today.replace(year=today.year + 1, month=1, day=1)
+    else:
+        next_month = today.replace(month=today.month + 1, day=1)
+    end = next_month - timedelta(days=1)
+
     result = Config.get_default_date_range()
-    assert "--" in result  # формат YYYY-MM-DD--YYYY-MM-DD
+    assert result == f"{start.isoformat()}--{end.isoformat()}"
 
 
 @mock.patch.dict(os.environ, {}, clear=True)
@@ -99,3 +109,27 @@ def test_get_redmine_verify_true_values(value):
 @mock.patch.dict(os.environ, {"REDMINE_VERIFY": "/tmp/redmine-ca.pem"}, clear=True)
 def test_get_redmine_verify_custom_path():
     assert Config.get_redmine_verify() == "/tmp/redmine-ca.pem"
+
+
+# -- #15: .env не должен переопределять переменные окружения --
+
+
+@mock.patch("dotenv.load_dotenv")
+def test_env_var_takes_priority_over_dotenv(mock_load):
+    """load_dotenv вызывается с override=False — env vars не перебиваются .env."""
+    import importlib
+
+    from redmine_reporter import config as cfg_mod
+
+    importlib.reload(cfg_mod)
+
+    mock_load.assert_called_once_with(override=False)
+
+
+# -- #35: get_redmine_password должен делать .strip() --
+
+
+@mock.patch.dict(os.environ, {"REDMINE_PASSWORD": "  secret123  "}, clear=True)
+def test_get_redmine_password_strips_whitespace():
+    """Пароль обрезается от whitespace, как и все остальные геттеры."""
+    assert Config.get_redmine_password() == "secret123"

tests/test_formatters.py

@@ -1,4 +1,5 @@
 import io
+import json
 from typing import List
 from unittest import mock
 
@@ -7,9 +8,12 @@ from odf.opendocument import OpenDocument, OpenDocumentText
 
 from redmine_reporter.formatters.console import CompactFormatter, TableFormatter
 from redmine_reporter.formatters.csv import CSVFormatter
+from redmine_reporter.formatters.factory import get_formatter_by_extension
 from redmine_reporter.formatters.html import HTMLFormatter
+from redmine_reporter.formatters.json import JSONFormatter
 from redmine_reporter.formatters.markdown import MarkdownFormatter
 from redmine_reporter.formatters.odt import ODTFormatter
+from redmine_reporter.formatters.xlsx import XLSXFormatter
 from redmine_reporter.types import ReportRow
 
 
@@ -38,6 +42,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Реализовать фичу X",
             "status_ru": "В работе",
             "time_text": "4ч 30м",
+            "hours": 4.5,
         },
         {
             "project": "Проект A",
@@ -48,6 +53,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Исправить баг Y",
             "status_ru": "Решена",
             "time_text": "2ч",
+            "hours": 2.0,
         },
         {
             "project": "Проект A",
@@ -58,6 +64,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Документация Z",
             "status_ru": "Ожидание",
             "time_text": "1ч",
+            "hours": 1.0,
         },
         {
             "project": "Проект B",
@@ -68,6 +75,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Обновить README",
             "status_ru": "Закрыто",
             "time_text": "0ч",
+            "hours": 0.0,
         },
         {
             "project": "Проект C",
@@ -78,6 +86,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Настроить CI",
             "status_ru": "В работе",
             "time_text": "3ч 15м",
+            "hours": 3.25,
         },
         {
             "project": "Проект C",
@@ -88,6 +97,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Добавить тесты",
             "status_ru": "В работе",
             "time_text": "5ч",
+            "hours": 5.0,
         },
         {
             "project": "Проект C",
@@ -98,6 +108,7 @@ def make_fake_report_rows() -> List[ReportRow]:
             "subject": "Рефакторинг",
             "status_ru": "Решена",
             "time_text": "6ч 45м",
+            "hours": 6.75,
         },
     ]
 
@@ -114,8 +125,6 @@ def odt_formatter():
     mock_file = mock.MagicMock()
     mock_file.__enter__ = mock.MagicMock(return_value=io.BytesIO(odt_bytes))
     mock_file.__exit__ = mock.MagicMock(return_value=False)
-    mock_path = mock.MagicMock()
-    mock_path.open.return_value = mock_file
 
     with mock.patch(
         "redmine_reporter.formatters.odt.resources.files",
@@ -128,12 +137,104 @@ def odt_formatter():
         yield ODTFormatter(author="Тест Автор", from_date="2026-01-01", to_date="2026-01-31")
 
 
+# -- Тесты упаковки formatters как полноценного пакета --
+
+
+def test_formatters_is_regular_package():
+    """redmine_reporter.formatters — полноценный пакет с __init__.py, не namespace."""
+    import redmine_reporter.formatters
+
+    assert hasattr(redmine_reporter.formatters, "__file__")
+    assert redmine_reporter.formatters.__file__.endswith("__init__.py")
+
+
+def test_formatters_found_by_setuptools():
+    """setuptools.find_packages находит formatters как полноценный пакет."""
+    import os
+
+    from setuptools import find_packages
+
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    found = find_packages(where=project_root, include=["redmine_reporter*"])
+    assert "redmine_reporter.formatters" in found
+
+
+# -- Тесты ленивого импорта ODT (#25) --
+
+
+def _simulate_missing_odfpy():
+    """Вспомогательная функция: подготавливает очистку кэша модулей odf и odt.
+
+    Возвращает словарь сохранённых модулей для последующего восстановления.
+    """
+    import sys
+
+    saved = {}
+    for key in list(sys.modules.keys()):
+        if key == "odf" or key.startswith("odf.") or key == "redmine_reporter.formatters.odt":
+            saved[key] = sys.modules.pop(key)
+    return saved
+
+
+def _restore_modules(saved):
+    import sys
+
+    sys.modules.update(saved)
+
+
+def test_get_formatter_odt_returns_none_without_odfpy():
+    """Без odfpy — get_formatter_by_extension('.odt') возвращает None, не падает."""
+    import builtins
+
+    from redmine_reporter.formatters.factory import get_formatter_by_extension
+
+    real_import = builtins.__import__
+
+    def blocking_import(name, *args, **kwargs):
+        if name == "odf" or name.startswith("odf."):
+            raise ImportError(f"No module named '{name}'")
+        return real_import(name, *args, **kwargs)
+
+    saved = _simulate_missing_odfpy()
+    try:
+        with mock.patch("builtins.__import__", side_effect=blocking_import):
+            result = get_formatter_by_extension(
+                ".odt", author="test", from_date="2026-01-01", to_date="2026-01-31"
+            )
+            assert result is None
+    finally:
+        _restore_modules(saved)
+
+
+def test_get_formatter_csv_works_without_odfpy():
+    """Без odfpy — get_formatter_by_extension('.csv') работает нормально."""
+    import builtins
+
+    from redmine_reporter.formatters.factory import get_formatter_by_extension
+
+    real_import = builtins.__import__
+
+    def blocking_import(name, *args, **kwargs):
+        if name == "odf" or name.startswith("odf."):
+            raise ImportError(f"No module named '{name}'")
+        return real_import(name, *args, **kwargs)
+
+    saved = _simulate_missing_odfpy()
+    try:
+        with mock.patch("builtins.__import__", side_effect=blocking_import):
+            result = get_formatter_by_extension(".csv")
+            assert result is not None
+    finally:
+        _restore_modules(saved)
+
+
 # -- Параметризованные тесты текстовых форматтеров --
 
 TEXT_FORMATTER_FACTORIES = [
     ("table", lambda: TableFormatter()),
     ("compact", lambda: CompactFormatter()),
     ("csv", lambda: CSVFormatter()),
+    ("json", lambda: JSONFormatter()),
     ("markdown", lambda: MarkdownFormatter()),
 ]
 
@@ -161,6 +262,10 @@ def test_text_formatter_contains_key_content(fake_rows, name, factory):
         # В CSV issue_id и subject -- отдельные колонки
         assert "101" in output
         assert "Реализовать фичу X" in output
+    elif name == "json":
+        # В JSON issue_id -- число, subject -- отдельное поле
+        assert '"issue_id": 101' in output
+        assert "Реализовать фичу X" in output
     else:
         assert "101. Реализовать фичу X" in output
 
@@ -185,6 +290,134 @@ def test_compact_formatter_save_raises(fake_rows):
         CompactFormatter().save(fake_rows, "/dev/null")
 
 
+def test_csv_save_writes_utf8_bom(fake_rows, tmp_path):
+    """CSV-файл начинается с UTF-8 BOM для корректного открытия в Excel (#26)."""
+    output = tmp_path / "report.csv"
+    CSVFormatter().save(fake_rows, str(output))
+    content = output.read_bytes()
+    assert content[:3] == b"\xef\xbb\xbf"  # UTF-8 BOM
+
+
+def test_csv_uses_full_values_not_display(fake_rows):
+    """CSV экспортирует полные project/version, а не display-значения (#31).
+
+    В отличие от консольных и Markdown форматтеров (display_*), CSV содержит
+    полные значения в каждой строке — это корректно для табличного формата.
+    """
+    output = CSVFormatter().format(fake_rows)
+    lines = output.strip().split("\n")
+    # Header + 7 data rows = 8 lines
+    assert len(lines) == 8
+    # Вторая строка данных (lines[2]) имеет display_project="" и display_version="",
+    # но CSV должен содержать полные значения
+    assert "Проект A" in lines[2]
+    assert "v1.0" in lines[2]
+
+
+def test_json_save_writes_parsable_data(fake_rows, tmp_path):
+    """JSON-файл содержит валидный JSON со всеми строками отчёта."""
+    output = tmp_path / "report.json"
+    JSONFormatter().save(fake_rows, str(output))
+    data = json.loads(output.read_text(encoding="utf-8"))
+    assert len(data) == len(fake_rows)
+    assert data[0]["project"] == "Проект A"
+    assert data[0]["issue_id"] == 101
+
+
+def test_get_formatter_by_extension_json():
+    """get_formatter_by_extension('.json') возвращает JSONFormatter."""
+    formatter = get_formatter_by_extension(".json")
+    assert isinstance(formatter, JSONFormatter)
+
+
+def test_get_formatter_by_extension_xlsx():
+    """get_formatter_by_extension('.xlsx') возвращает XLSXFormatter."""
+    formatter = get_formatter_by_extension(".xlsx")
+    assert isinstance(formatter, XLSXFormatter)
+
+
+def test_xlsx_save_creates_valid_file(fake_rows, tmp_path):
+    """XLSX-файл сохраняется и содержит корректные данные."""
+    from openpyxl import load_workbook
+
+    output = tmp_path / "report.xlsx"
+    XLSXFormatter().save(fake_rows, str(output))
+
+    wb = load_workbook(str(output))
+    ws = wb.active
+    assert ws.title == "Report"
+    assert ws["A1"].value == "Project"
+    assert ws["A2"].value == "Проект A"
+    assert ws["C2"].value == 101
+    assert ws["F2"].value == 4.5
+    assert ws["G2"].value == "4ч 30м"
+    # header + 7 data rows + 5 version totals + 3 project totals + 1 grand total
+    assert ws.max_row == 17
+
+
+def test_xlsx_has_merged_cells(fake_rows, tmp_path):
+    """XLSX содержит объединённые ячейки по проектам и версиям."""
+    from openpyxl import load_workbook
+
+    output = tmp_path / "report.xlsx"
+    XLSXFormatter().save(fake_rows, str(output))
+
+    wb = load_workbook(str(output))
+    ws = wb.active
+    merged_ranges = [str(r) for r in ws.merged_cells.ranges]
+    # Проект A: 3 строки данных + 2 итога по версиям + 1 итог по проекту = строки 2-7
+    assert any("A2:A7" in r for r in merged_ranges)
+    # Версия v1.0 проекта A: 2 строки данных + 1 итог по версии = строки 2-4
+    assert any("B2:B4" in r for r in merged_ranges)
+
+
+def test_xlsx_has_totals(fake_rows, tmp_path):
+    """XLSX содержит итоги по версиям, проектам и общий итог."""
+    from openpyxl import load_workbook
+
+    output = tmp_path / "report.xlsx"
+    XLSXFormatter().save(fake_rows, str(output))
+
+    wb = load_workbook(str(output))
+    ws = wb.active
+
+    total_values = [ws.cell(row=r, column=6).value for r in range(2, ws.max_row + 1)]
+    # Проект A всего: 4.5 + 2 + 1 = 7.5
+    assert 7.5 in total_values
+    # Общий итог: 4.5 + 2 + 1 + 0 + 3.25 + 5 + 6.75 = 22.5
+    assert 22.5 in total_values
+    # Проверим числовой формат
+    assert ws["F2"].number_format == "0.00"
+
+
+def test_xlsx_no_time_keeps_columns_empty_and_skips_totals(fake_rows, tmp_path):
+    """XLSX с no_time: колонки времени пустые, итогов нет."""
+    from openpyxl import load_workbook
+
+    output = tmp_path / "report.xlsx"
+    XLSXFormatter(no_time=True).save(fake_rows, str(output))
+
+    wb = load_workbook(str(output))
+    ws = wb.active
+
+    # header + 7 data rows
+    assert ws.max_row == 8
+
+    # Колонки времени пустые для всех строк данных
+    for row in range(2, ws.max_row + 1):
+        assert ws.cell(row=row, column=6).value in (None, "")
+        assert ws.cell(row=row, column=7).value in (None, "")
+
+    # Итоговых строк нет
+    for row in range(2, ws.max_row + 1):
+        assert not str(ws.cell(row=row, column=1).value or "").startswith("Total")
+        assert not str(ws.cell(row=row, column=2).value or "").startswith("Total")
+
+    # Автофильтр и freeze panes на месте
+    assert ws.freeze_panes == "A2"
+    assert ws.auto_filter.ref == "A1:G8"
+
+
 def test_markdown_formatter_escapes_table_cells():
     rows = make_fake_report_rows()
     rows[0]["project"] = "A|B"
@@ -210,6 +443,13 @@ def test_html_formatter_escapes_cells():
     assert "Fix <tag>" not in output
 
 
+def test_html_output_has_doctype_and_charset(fake_rows):
+    """HTML-отчёт содержит DOCTYPE и meta charset для корректной кодировки (#27)."""
+    output = HTMLFormatter().format(fake_rows)
+    assert "<!DOCTYPE html>" in output
+    assert '<meta charset="utf-8">' in output
+
+
 # -- Тесты ODT форматтера --
 
 
@@ -219,6 +459,33 @@ def test_odt_formatter_returns_opendocument(fake_rows, odt_formatter):
     assert isinstance(result, OpenDocument)
 
 
+def test_odt_empty_author_no_garbage_in_header(fake_rows):
+    """При пустом авторе заголовок не содержит мусорных символов (#30)."""
+    odt_bytes = _make_empty_odt_bytes()
+    mock_file = mock.MagicMock()
+    mock_file.__enter__ = mock.MagicMock(return_value=io.BytesIO(odt_bytes))
+    mock_file.__exit__ = mock.MagicMock(return_value=False)
+
+    with mock.patch(
+        "redmine_reporter.formatters.odt.resources.files",
+        return_value=mock.MagicMock(
+            joinpath=mock.MagicMock(
+                return_value=mock.MagicMock(open=mock.MagicMock(return_value=mock_file))
+            )
+        ),
+    ):
+        formatter = ODTFormatter(author="", from_date="2026-01-01", to_date="2026-01-31")
+        doc = formatter.format(fake_rows)
+
+        from odf.text import P
+
+        paragraphs = doc.text.getElementsByType(P)
+        header_text = paragraphs[0].firstChild.data
+
+        assert not header_text.startswith(".")
+        assert "Отчет за месяц" in header_text
+
+
 def test_odt_formatter_save_creates_valid_file(fake_rows, tmp_path):
     """ODT можно сохранить -- файл валиден (сигнатура ZIP)."""
     odt_bytes = _make_empty_odt_bytes()
@@ -240,3 +507,40 @@ def test_odt_formatter_save_creates_valid_file(fake_rows, tmp_path):
 
     assert output_file.exists()
     assert output_file.read_bytes()[:2] == b"PK"  # сигнатура ZIP
+
+
+def test_odt_has_covered_cells_for_spans(fake_rows):
+    """ODT содержит covered-table-cell для замещённых ячеек при объединении (#13).
+
+    Тестовые данные (fake_rows):
+      Проект A: v1.0(2 задачи), v2.0(1) → project span=3
+        row1: project+version (0 covered)
+        row2: covered project + covered version (2)
+        row3: covered project + new version cell (1)
+      Проект B: <N/A>(1) → span=1, нет covered
+      Проект C: v1.0(1), v1.1(2) → project span=3
+        row5: project+version (0 covered)
+        row6: covered project + new version cell (1)
+        row7: covered project + covered version (2)
+      Итого: 6 covered cells
+    """
+    odt_bytes = _make_empty_odt_bytes()
+    mock_file = mock.MagicMock()
+    mock_file.__enter__ = mock.MagicMock(return_value=io.BytesIO(odt_bytes))
+    mock_file.__exit__ = mock.MagicMock(return_value=False)
+
+    with mock.patch(
+        "redmine_reporter.formatters.odt.resources.files",
+        return_value=mock.MagicMock(
+            joinpath=mock.MagicMock(
+                return_value=mock.MagicMock(open=mock.MagicMock(return_value=mock_file))
+            )
+        ),
+    ):
+        formatter = ODTFormatter(author="Тест", from_date="2026-01-01", to_date="2026-01-31")
+        doc = formatter.format(fake_rows)
+
+        from odf.table import CoveredTableCell
+
+        covered_cells = doc.getElementsByType(CoveredTableCell)
+        assert len(covered_cells) == 6

tests/test_report_builder.py

@@ -1,4 +1,9 @@
-from redmine_reporter.report_builder import STATUS_TRANSLATION, build_grouped_report
+from redmine_reporter.report_builder import (
+    STATUS_TRANSLATION,
+    build_grouped_report,
+    calculate_summary,
+    group_rows_by_project_and_version,
+)
 
 
 class MockIssue:
@@ -56,7 +61,61 @@ def test_build_grouped_report_grouping():
 
     assert rows[0]["status_ru"] == "В работе"
     assert rows[0]["time_text"] == "2ч"
+    assert rows[0]["hours"] == 2.0
     assert rows[1]["time_text"] == "1ч 30м"
+    assert rows[1]["hours"] == 1.5
+
+
+# -- #22: Сводка по времени --
+
+
+def test_calculate_summary_totals():
+    """Сводка содержит общее время и разбивку по проектам/версиям."""
+    rows = [
+        {
+            "project": "Камеры",
+            "version": "v2.5.0",
+            "issue_id": 101,
+            "subject": "Фича A",
+            "status_ru": "В работе",
+            "time_text": "2ч",
+            "hours": 2.0,
+        },
+        {
+            "project": "Камеры",
+            "version": "v2.5.0",
+            "issue_id": 102,
+            "subject": "Баг B",
+            "status_ru": "Решена",
+            "time_text": "1ч 30м",
+            "hours": 1.5,
+        },
+        {
+            "project": "ПО",
+            "version": "<N/A>",
+            "issue_id": 201,
+            "subject": "Доки",
+            "status_ru": "Ожидание",
+            "time_text": "4ч",
+            "hours": 4.0,
+        },
+    ]
+    summary = calculate_summary(rows)
+
+    assert summary["total"] == 7.5
+    assert summary["project:Камеры"] == 3.5
+    assert summary["project:ПО"] == 4.0
+    assert summary["version:Камеры::v2.5.0"] == 3.5
+    assert summary["version:ПО::<N/A>"] == 4.0
+
+
+def test_calculate_summary_empty():
+    """Сводка для пустого списка -- только total = 0."""
+    summary = calculate_summary([])
+    assert summary == {"total": 0.0}
+
+
+# -- #19: Общая функция группировки --
 
 
 def test_build_grouped_report_new_version_same_project():
@@ -105,3 +164,116 @@ def test_build_grouped_report_preserves_issue_id_and_subject():
     rows = build_grouped_report(issues)
     assert rows[0]["issue_id"] == 42
     assert rows[0]["subject"] == "Моя задача"
+
+
+def test_build_grouped_report_deterministic_order_within_group():
+    """Задачи в одной группе проект+версия упорядочены по issue.id
+    независимо от порядка на входе (#33)."""
+    issues = [
+        (MockIssue("P", "Task C", "New", "v1.0", 103), 1.0),
+        (MockIssue("P", "Task A", "New", "v1.0", 101), 1.0),
+        (MockIssue("P", "Task B", "New", "v1.0", 102), 1.0),
+    ]
+    rows = build_grouped_report(issues)
+    assert [r["issue_id"] for r in rows] == [101, 102, 103]
+
+
+# -- #19: Общая функция группировки --
+
+
+def test_group_rows_basic():
+    """Два проекта, в одном две версии — структура корректна."""
+    rows = [
+        {
+            "project": "A",
+            "version": "v1",
+            "issue_id": 1,
+            "subject": "T1",
+            "status_ru": "S",
+            "time_text": "1ч",
+        },
+        {
+            "project": "A",
+            "version": "v2",
+            "issue_id": 2,
+            "subject": "T2",
+            "status_ru": "S",
+            "time_text": "2ч",
+        },
+        {
+            "project": "B",
+            "version": "v1",
+            "issue_id": 3,
+            "subject": "T3",
+            "status_ru": "S",
+            "time_text": "3ч",
+        },
+    ]
+    grouped = group_rows_by_project_and_version(rows)
+
+    assert list(grouped.keys()) == ["A", "B"]
+    assert list(grouped["A"].keys()) == ["v1", "v2"]
+    assert list(grouped["B"].keys()) == ["v1"]
+    assert len(grouped["A"]["v1"]) == 1
+    assert len(grouped["A"]["v2"]) == 1
+    assert len(grouped["B"]["v1"]) == 1
+
+
+def test_group_rows_multiple_tasks_per_version():
+    """Несколько задач в одной версии — все попадают в список."""
+    rows = [
+        {
+            "project": "A",
+            "version": "v1",
+            "issue_id": 1,
+            "subject": "T1",
+            "status_ru": "S",
+            "time_text": "1ч",
+        },
+        {
+            "project": "A",
+            "version": "v1",
+            "issue_id": 2,
+            "subject": "T2",
+            "status_ru": "S",
+            "time_text": "2ч",
+        },
+        {
+            "project": "A",
+            "version": "v1",
+            "issue_id": 3,
+            "subject": "T3",
+            "status_ru": "S",
+            "time_text": "3ч",
+        },
+    ]
+    grouped = group_rows_by_project_and_version(rows)
+
+    assert len(grouped["A"]["v1"]) == 3
+    assert [r["issue_id"] for r in grouped["A"]["v1"]] == [1, 2, 3]
+
+
+def test_group_rows_preserves_row_data():
+    """Строки в группировке — те же объекты, без потери данных."""
+    rows = [
+        {
+            "project": "P",
+            "version": "v1",
+            "issue_id": 42,
+            "subject": "Task",
+            "status_ru": "Готово",
+            "time_text": "5ч",
+        },
+    ]
+    grouped = group_rows_by_project_and_version(rows)
+
+    row = grouped["P"]["v1"][0]
+    assert row["issue_id"] == 42
+    assert row["subject"] == "Task"
+    assert row["status_ru"] == "Готово"
+    assert row["time_text"] == "5ч"
+
+
+def test_group_rows_empty():
+    """Пустой список — пустой словарь."""
+    assert group_rows_by_project_and_version([]) == {}

tests/test_utils.py

@@ -78,3 +78,35 @@ def test_get_version_none_attribute():
         fixed_version = None
 
     assert get_version(MockIssue()) == "<N/A>"
+
+
+def test_get_version_with_redminelib_version_object():
+    """redminelib Version: str() возвращает ID, .name — человекочитаемое имя."""
+
+    class MockVersion:
+        """Имитирует redminelib.resources.Version — str() даёт ID."""
+
+        def __init__(self, vid, name):
+            self.id = vid
+            self.name = name
+
+        def __str__(self):
+            return str(self.id)
+
+    class MockIssue:
+        fixed_version = MockVersion(42, "v2.5.0")
+
+    assert get_version(MockIssue()) == "v2.5.0"
+
+
+def test_get_version_falls_back_to_str_when_no_name():
+    """Если у объекта версии нет .name — fallback на str()."""
+
+    class MockVersionNoName:
+        def __str__(self):
+            return "fallback-id"
+
+    class MockIssue:
+        fixed_version = MockVersionNoName()
+
+    assert get_version(MockIssue()) == "fallback-id"