chore(release): bump version to 1.6.0

Bump version from 1.5.0 to 1.6.0 in __init__.py and pyproject.toml.
Update test_cli_version_flag to assert against the current package
version instead of a hardcoded string.

.gitignore

@@ -91,3 +91,4 @@ secrets.json
 report.odt
 report.csv
 report.md
+*.html

README.md

@@ -1,60 +1,56 @@
 # redmine-reporter
 
-Инструмент для генерации отчётов по задачам в Redmine на основе ваших записей о затраченном времени.
+CLI-инструмент для генерации отчётов по задачам Redmine на основе записей о затраченном времени.
 
-> Предназначен для внутреннего использования в Eltex. Работает с `https://red.eltex.loc/`.
+Проект предназначен для внутреннего использования с `https://red.eltex.loc/`.
 
-📄 **Лицензия**: [MIT](./LICENSE) — делайте что угодно.
+Лицензия: MIT.
 
----
+## Возможности
 
-## 🔧 Возможности
+- Получение time entries текущего пользователя из Redmine.
+- Авторизация через Redmine API token.
+- Резервная авторизация через логин и пароль для обратной совместимости.
+- Группировка задач по проекту и версии.
+- Перевод статусов задач на русский язык.
+- Вывод в консоль в табличном или компактном виде.
+- Экспорт в ODT, CSV, Markdown, HTML, JSON и Excel (.xlsx).
+- Сводка по затраченному времени (итоги и разбивка по проектам/версиям).
+- Автоматическое определение месяца ODT-отчёта по конечной дате периода.
+- Настройка периода отчёта по умолчанию через `.env` (или автоматически — текущий месяц).
+- Переопределение URL и API-ключа через CLI.
+- Загрузка альтернативного `.env` через `--config`.
+- Загрузка альтернативного `.env` через `--config`.
 
-- Безопасная передача учётных данных через переменные окружения или `.env`
+## Установка
-- Два режима вывода: компактный (для копирования) и табличный (для просмотра)
-- Группировка задач по проекту и версии
-- Перевод статусов на русский язык
-- Простой CLI с понятными аргументами
-- Поддержка настройки диапазона дат по умолчанию через `.env`
-- Экспорт в ODT, CSV и Markdown
-
----
-
-## 🚀 Установка и настройка (продакшен)
-
-### 1. Клонируйте репозиторий
 
 ```bash
 git clone https://git.akokos.ru/artem.kokos/redmine-reporter.git
 cd redmine-reporter
-```
-
-### 2. Создайте изолированное окружение и установите зависимости
-
-```bash
 python3 -m venv .venv
 source .venv/bin/activate
 pip install --upgrade pip
 pip install .
 ```
 
-> 💡 Установка в виртуальное окружение — стандарт для Python-инструментов. Это безопасно и не влияет на систему.
+## Настройка
 
-### 3. Настройте доверие к корпоративному сертификату (обязательно!)
+Создайте файл `.env` в корне проекта. Файл не должен попадать в git.
 
-По умолчанию Python использует собственный набор сертификатов (`certifi`), который **не включает** внутренние CA Eltex.  
+Рекомендуемый вариант авторизации:
-Чтобы избежать ошибки `CERTIFICATE_VERIFY_FAILED`, выполните **один раз**:
 
-```bash
+```ini
-cat /etc/ssl/certs/ca-certificates.crt >> $(python -m certifi)
+REDMINE_URL=https://red.eltex.loc/
+REDMINE_API_KEY=ваш_api_token
+REDMINE_AUTHOR=Иванов Иван Иванович
+
+DEFAULT_FROM_DATE=2026-01-01
+DEFAULT_TO_DATE=2026-01-31
 ```
 
-> ✅ Это безопасно: вы просто добавляете доверенные системные сертификаты к Python.  
+Если задан `REDMINE_API_KEY`, он используется в первую очередь. Значения из `.env` можно переопределить через CLI: `--url`, `--api-key`, `--author`, а также загрузить другой файл конфигурации через `--config`.
-> ❌ Не используйте `verify=False` — это создаёт уязвимость.
 
-### 4. Настройте учётные данные и (опционально) даты
+Резервный вариант авторизации:
-
-Создайте файл `.env` в корне проекта (**никогда не коммитьте его!**):
 
 ```ini
 REDMINE_URL=https://red.eltex.loc/
@@ -62,99 +58,152 @@ REDMINE_USER=ваш.логин
 REDMINE_PASSWORD=ваш_пароль
 REDMINE_AUTHOR=Иванов Иван Иванович
 
-# Опционально: диапазон дат по умолчанию
 DEFAULT_FROM_DATE=2026-01-01
 DEFAULT_TO_DATE=2026-01-31
 ```
 
-Альтернатива — задать переменные вручную:
+Переменные окружения:
 
-```bash
+| Переменная | Обязательность | Описание |
-export REDMINE_URL=https://red.eltex.loc/
+| --- | --- | --- |
-export REDMINE_USER=ваш.логин
+| `REDMINE_URL` | Да | URL Redmine. |
-export REDMINE_PASSWORD=...
+| `REDMINE_API_KEY` | Да, если нет логина и пароля | Redmine API token. |
-export REDMINE_AUTHOR="Иванов Иван Иванович"
+| `REDMINE_USER` | Да, если нет токена | Логин Redmine. |
-export DEFAULT_FROM_DATE=2026-01-01
+| `REDMINE_PASSWORD` | Да, если нет токена | Пароль Redmine. |
-export DEFAULT_TO_DATE=2026-01-31
+| `REDMINE_AUTHOR` | Нет | Имя автора для ODT-отчёта. |
-```
+| `DEFAULT_FROM_DATE` | Нет | Начальная дата периода по умолчанию в формате `YYYY-MM-DD`. |
+| `DEFAULT_TO_DATE` | Нет | Конечная дата периода по умолчанию в формате `YYYY-MM-DD`. |
+| `REDMINE_VERIFY` | Нет | Настройка TLS-проверки для Redmine API. |
 
-> 🔐 Рекомендуется использовать аккаунт с минимальными правами (только чтение time entries и задач).
+`REDMINE_VERIFY` поддерживает значения:
-> 💡 Если `DEFAULT_FROM_DATE` и `DEFAULT_TO_DATE` не заданы, используется встроенный диапазон: `2025-12-19--2026-01-31`.
 
----
+- пустое значение или отсутствие переменной: `/etc/ssl/certs/ca-certificates.crt`;
+- `true`, `1`, `yes`, `on`: стандартная проверка сертификатов `requests`;
+- `false`, `0`, `no`, `off`: отключить проверку сертификатов;
+- любой другой текст: путь к CA bundle.
 
-## ▶️ Использование
+Отключать проверку сертификатов не рекомендуется.
 
-Перед каждым запуском активируйте окружение:
+## Использование
 
 ```bash
 source .venv/bin/activate
 ```
 
-Затем:
+Отчёт за период по умолчанию (текущий месяц или из `.env`):
 
 ```bash
-# Отчёт за период по умолчанию (из .env или встроенный)
 redmine-reporter
+```
 
-# Отчёт за произвольный период (переопределяет .env)
+Отчёт за произвольный период:
+
+```bash
 redmine-reporter --date 2026-02-01--2026-02-28
+```
 
-# Компактный вывод (удобно копировать в письмо)
+Период должен быть задан в формате `YYYY-MM-DD--YYYY-MM-DD`. Начальная дата не может быть позже конечной.
+
+Переопределение URL и API-ключа из `.env`:
+
+```bash
+redmine-reporter --url https://red.example.com --api-key ваш_токен
+```
+
+Использование альтернативного конфигурационного файла:
+
+```bash
+redmine-reporter --config /path/to/.env
+```
+
+Компактный вывод:
+
+```bash
 redmine-reporter --compact
-
-# Экспорт в ODT с указанием автора (если не задано в .env)
-redmine-reporter --output report.odt --author "Иванов Иван Иванович"
 ```
 
-> 💡 **Автоматика в ODT-отчёте**:
+Подробный или отладочный вывод:
-> - Месяц в заголовке определяется **автоматически** по дате окончания периода (`to_date`).
->   Например: `2025-12-20--2026-01-15` → **«Январь»**.
-> - Имя автора берётся из переменной окружения `REDMINE_AUTHOR` (в `.env`) или CLI-аргумента `--author`.
-> - Первая пустая строка из шаблона `template.odt` **автоматически удаляется**.
 
-Пример содержимого `.env` с автором:
+```bash
-
+redmine-reporter --verbose
-```ini
+redmine-reporter --debug
-REDMINE_URL=https://red.eltex.loc/
-REDMINE_USER=ваш.логин
-REDMINE_PASSWORD=ваш_пароль
-REDMINE_AUTHOR=Иванов Иван Иванович
-DEFAULT_FROM_DATE=2026-01-01
-DEFAULT_TO_DATE=2026-01-31
 ```
 
-Пример вывода в ODT (заголовок):
+Вывод версии:
-> **Иванов Иван Иванович. Отчёт за месяц Январь.**
 
-Пример консольного вывода:
+```bash
-```
+redmine-reporter --version
-✅ Total issues: 7 [2026-01-01--2026-01-31]
-╒════════════╤═══════════╤══════════════════════════════════════╤═══════════╤════════════╕
-│ Проект     │ Версия    │ Задача                               │ Статус    │ Затрачено  │
-╞════════════╪═══════════╪══════════════════════════════════════╪═══════════╪════════════╡
-│ Камеры     │ v2.5.0    │ 12345. Поддержка нового датчика      │ В работе  │ 2.00h      │
-│            │           │ 12346. Исправить утечку памяти       │ Решена    │ 2.00h      │
-│ ПО         │ <N/A>     │ 12350. Обновить документацию         │ Ожидание  │ 12.00h     │
-╘════════════╧═══════════╧══════════════════════════════════════╧═══════════╧════════════╛
 ```
 
----
+Экспорт:
 
-## 🛠 Разработка
+```bash
+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
+```
 
-Для участия в разработке:
+JSON-отчёт:
+
+- массив объектов с полями `project`, `version`, `issue_id`, `subject`, `status`, `time`;
+- UTF-8, читаемый машиной.
+
+Excel-отчёт (.xlsx):
+
+- одна таблица с заголовками и строками данных;
+- шапка выделена жирным;
+- каждая строка содержит полные значения проекта и версии.
+
+CSV-отчёт:
+
+- файл сохраняется в UTF-8 с BOM (`utf-8-sig`) для корректного отображения кириллицы в Microsoft Excel;
+- каждая строка содержит полные значения проекта и версии (в отличие от консольного и Markdown-вывода, где повторяющиеся значения скрыты для компактности).
+
+HTML-отчёт:
+
+- полноценный HTML-документ с `<meta charset="utf-8">`;
+- корректно отображается в браузере и почтовых клиентах.
+
+ODT-отчёт:
+
+- месяц в заголовке определяется по `to_date`;
+- имя автора берётся из `--author`, затем из `REDMINE_AUTHOR`;
+- если автор не задан, поле автора остаётся пустым.
+
+Вывод без затраченного времени:
+
+```bash
+redmine-reporter --no-time
+```
+
+Сводка по времени (итоги и разбивка по проектам):
+
+```bash
+redmine-reporter --summary
+```
+
+## Разработка
+
+Установка зависимостей для разработки:
 
 ```bash
 pip install -e ".[dev]"
-pytest
-black .
-isort .
 ```
 
----
+Проверки:
 
-> 🔒 **Важно**:  
+```bash
-> - Никогда не коммитьте `.env`, пароли или логины.
+pytest
-> - Файл `.gitignore` уже исключает все чувствительные артефакты.  
+ruff check redmine_reporter tests
-> - Инструмент работает только в режиме **чтения** — он не может изменять данные в Redmine.
+black redmine_reporter tests
+isort redmine_reporter tests
+```
+
+## Безопасность
+
+- Не коммитьте `.env`, API token, пароль или логин.
+- Используйте аккаунт с минимальными правами, достаточными для чтения time entries и задач.
+- Инструмент работает только в режиме чтения и не изменяет данные в Redmine.

pyproject.toml

@@ -4,26 +4,26 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redmine-reporter"
-version = "1.3.0"
+version = "1.6.0"
 description = "Redmine time-entry based issue reporter for internal use"
 readme = "README.md"
 authors = [{ name = "Artem Kokos", email = "artem-kokos@mail.ru" }]
 license = { text = "MIT" }
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Operating System :: POSIX :: Linux",
     "Environment :: Console",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = [
     "python-redmine>=2.4.0",
     "tabulate>=0.9.0",
     "python-dotenv>=1.0.0",
     "odfpy>=1.4.0",
+    "openpyxl>=3.1.0",
 ]
 
 [project.optional-dependencies]
@@ -42,10 +42,20 @@ redmine-reporter = "redmine_reporter.cli:main"
 where = ["."]
 include = ["redmine_reporter*"]
 
+[tool.setuptools.package-data]
+"redmine_reporter" = ["templates/template.odt"]
+
 [tool.black]
 line-length = 100
-target-version = ['py38']
+target-version = ['py39']
 
 [tool.isort]
 profile = "black"
 multi_line_output = 3
+
+[tool.mypy]
+warn_unused_configs = true
+
+[[tool.mypy.overrides]]
+module = ["odf.*", "redminelib.*", "tabulate", "openpyxl.*"]
+ignore_missing_imports = true

redmine_reporter/__init__.py

@@ -1 +1 @@
-__version__ = "1.3.0"
+__version__ = "1.6.0"

redmine_reporter/cli.py

@@ -1,58 +1,97 @@
-import sys
 import argparse
+import logging
+import os
+import re
+import sys
+from datetime import datetime
 from typing import List, Optional
-from redminelib.resources import Issue
 
-from .config import Config
+from . import __version__
 from .client import fetch_issues_with_spent_time
-from .report_builder import build_grouped_report
+from .config import Config
-from .formatter import format_compact, format_table
+from .formatters.factory import get_console_formatter, get_formatter_by_extension
-from .formatter_odt import format_odt
+from .report_builder import build_grouped_report, calculate_summary
-from .formatter_csv import format_csv
-from .formatter_md import format_md
 
 
 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()
-    return parts[0].strip(), parts[1].strip()
+    date_pattern = r"\d{4}-\d{2}-\d{2}"
+    if not re.fullmatch(date_pattern, from_date) or not re.fullmatch(date_pattern, to_date):
+        raise ValueError("Date range must be in format YYYY-MM-DD--YYYY-MM-DD")
+
+    try:
+        start = datetime.strptime(from_date, "%Y-%m-%d").date()
+        end = datetime.strptime(to_date, "%Y-%m-%d").date()
+    except ValueError as e:
+        raise ValueError("Date range contains invalid calendar date") from e
+
+    if start > end:
+        raise ValueError("Date range start must be less than or equal to end")
+
+    return start.isoformat(), end.isoformat()
 
 
 def main(argv: Optional[List[str]] = None) -> int:
     parser = argparse.ArgumentParser(
         prog="redmine-reporter",
-        description="Generate Redmine issue report based on your time entries."
+        description="Generate Redmine issue report based on your time entries.",
     )
     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",
         action="store_true",
-        help="Use compact plain-text output instead of table"
+        help="Use compact plain-text output instead of table",
     )
     parser.add_argument(
         "--output",
-        help="Path to output .odt file (e.g., report.odt). 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",
+        "--author", default="", help="Override author name from .env (REDMINE_AUTHOR)"
-        default="",
-        help="Override author name from .env (REDMINE_AUTHOR)"
     )
     parser.add_argument(
-        "--no-time",
+        "--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="Do not include spent time into table"
+        help="Print summary (total hours by project/version) to stderr",
     )
     args = parser.parse_args(argv)
 
+    # 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:
@@ -75,50 +114,74 @@ def main(argv: Optional[List[str]] = None) -> int:
         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:
-        if not (args.output.endswith(".odt") or args.output.endswith(".csv") or args.output.endswith(".md")):
+        output_ext = os.path.splitext(args.output)[1].lower()
-            print("❌ Output file must end with .odt, .csv or .md", file=sys.stderr)
+
+        if not output_ext:
+            print(
+                "❌ Файл без расширения. Укажите расширение: .odt, .csv, .md, .html, .json или .xlsx",
+                file=sys.stderr,
+            )
+            return 1
+
+        formatter = get_formatter_by_extension(
+            output_ext,
+            author=Config.get_author(args.author),
+            from_date=from_date,
+            to_date=to_date,
+        )
+
+        if not formatter:
+            if output_ext == ".odt":
+                print(
+                    "❌ odfpy is not installed. Install with: pip install odfpy",
+                    file=sys.stderr,
+                )
+            else:
+                known_exts = ", ".join([".odt", ".csv", ".md", ".html", ".json", ".xlsx"])
+                print(
+                    f"❌ Неизвестный формат файла: {output_ext!r}. "
+                    f"Поддерживаются: {known_exts}",
+                    file=sys.stderr,
+                )
             return 1
 
         try:
-            if args.output.endswith(".odt"):
+            formatter.save(rows, args.output)
-                doc = format_odt(
-                    rows,
-                    author=Config.get_author(args.author),
-                    from_date=from_date,
-                    to_date=to_date,
-                )
-                doc.save(args.output)
-            elif args.output.endswith(".csv"):
-                content = format_csv(rows)
-                with open(args.output, "w", encoding="utf-8", newline="") as f:
-                    f.write(content)
-            elif args.output.endswith(".md"):
-                content = format_md(rows)
-                with open(args.output, "w", encoding="utf-8") as f:
-                    f.write(content)
-
             print(f"✅ Report saved to {args.output}")
-        except ImportError as e:
-            if args.output.endswith(".odt"):
-                print("❌ odfpy is not installed. Install with: pip install odfpy", file=sys.stderr)
-            else:
-                print(f"❌ Import error: {e}", file=sys.stderr)
-            return 1
         except Exception as e:
-            fmt = "ODT" if args.output.endswith(".odt") else ("CSV" if args.output.endswith(".csv") else "Markdown")
+            fmt = output_ext.lstrip(".").upper()
             print(f"❌ {fmt} export error: {e}", file=sys.stderr)
             return 1
+
     else:
+        if args.compact:
+            formatter = get_console_formatter("compact")
+        else:
+            formatter = get_console_formatter("table")
+
+        if not formatter:
+            print("❌ Неизвестный тип консольного форматтера.", file=sys.stderr)
+            return 1
+
         try:
-            if args.compact:
+            output = formatter.format(rows)
-                output = format_compact(rows)
-            else:
-                output = format_table(rows)
             print(output)
         except Exception as e:
             print(f"❌ Formatting error: {e}", file=sys.stderr)

redmine_reporter/client.py

@@ -1,36 +1,93 @@
-from typing import List, Optional, Dict, Tuple
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
 from redminelib import Redmine
 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
 
 
-def fetch_issues_with_spent_time(from_date: str, to_date: str) -> Optional[List[Tuple[Issue, float]]]:
+def _get_redmine_auth_kwargs() -> Dict[str, Any]:
+    """Return Redmine auth kwargs. API key has priority over legacy password auth."""
+    api_key = Config.get_redmine_api_key()
+    if api_key:
+        return {"key": api_key}
+    return {
+        "username": Config.get_redmine_user(),
+        "password": Config.get_redmine_password(),
+    }
+
+
+def _make_retry_adapter() -> requests.adapters.HTTPAdapter:
+    """Создаёт HTTPAdapter с retry для временных ошибок (#24)."""
+    retry = Retry(
+        total=3,
+        backoff_factor=0.5,
+        status_forcelist=[429, 500, 502, 503, 504],
+        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(),
+            "timeout": REQUEST_TIMEOUT,
+        },
+    )
+
+    # Монтируем retry-адаптер на сессию для автоматических повторов.
+    # В python-redmine сессия живёт в engine, а redmine.session — контекстный менеджер.
+    retry_adapter = _make_retry_adapter()
+    redmine.engine.session.mount("https://", retry_adapter)
+    redmine.engine.session.mount("http://", retry_adapter)
+
+    return redmine
+
+
+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 fetch_issues_with_spent_time(
+    from_date: str, to_date: str
+) -> Optional[List[Tuple[Issue, float]]]:
     """
     Fetch unique issues linked to time entries of the current user in given date range,
     along with total spent hours per issue.
     Returns list of (issue, total_hours) tuples.
     """
 
-    redmine = Redmine(
+    redmine = _create_redmine()
-        Config.REDMINE_URL,
-        username=Config.REDMINE_USER,
-        password=Config.REDMINE_PASSWORD,
-        requests={'verify': '/etc/ssl/certs/ca-certificates.crt'}
-    )
 
-    current_user = redmine.user.get('current')
+    current_user = redmine.user.get("current")
     time_entries = redmine.time_entry.filter(
-        user_id=current_user.id,
+        user_id=current_user.id, from_date=from_date, to_date=to_date
-        from_date=from_date,
-        to_date=to_date
     )
 
     # Агрегируем часы по issue.id
     spent_time: Dict[int, float] = {}
     issue_ids = set()
     for entry in time_entries:
-        if hasattr(entry, 'issue') and entry.issue and hasattr(entry, 'hours'):
+        if hasattr(entry, "issue") and entry.issue and hasattr(entry, "hours"):
             iid = entry.issue.id
             issue_ids.add(iid)
             spent_time[iid] = spent_time.get(iid, 0.0) + float(entry.hours)
@@ -38,21 +95,16 @@ def fetch_issues_with_spent_time(from_date: str, to_date: str) -> Optional[List[
     if not issue_ids:
         return None
 
-    # Загружаем полные объекты задач
+    # Загружаем полные объекты задач чанками (#21)
-    issue_list_str = ','.join(str(i) for i in issue_ids)
+    sorted_ids = sorted(issue_ids)
-    issues = redmine.issue.filter(
+    issues = _fetch_issues_chunked(redmine, sorted_ids)
-        issue_id=issue_list_str,
-        status_id='*',
-        sort='project:asc'
-    )
 
-    # Сопоставляем задачи с суммарным временем
+    # Сопоставляем задачи с суммарным временем.
+    # Сортировка выполняется в 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,39 +1,98 @@
 import os
+from datetime import date, timedelta
+from typing import Union
+
 from dotenv import load_dotenv
 
+load_dotenv(override=False)
 
-load_dotenv()
+DEFAULT_REDMINE_VERIFY = "/etc/ssl/certs/ca-certificates.crt"
+FALSE_VALUES = {"0", "false", "no", "off"}
+TRUE_VALUES = {"1", "true", "yes", "on"}
 
 
 class Config:
-    REDMINE_URL = os.getenv("REDMINE_URL", "").rstrip("/")
+    _cli_url: str | None = None
-    REDMINE_USER = os.getenv("REDMINE_USER")
+    _cli_api_key: str | None = None
-    REDMINE_PASSWORD = os.getenv("REDMINE_PASSWORD")
+
-    REDMINE_AUTHOR = os.getenv("REDMINE_AUTHOR")
+    @classmethod
-    DEFAULT_FROM_DATE = os.getenv("DEFAULT_FROM_DATE")
+    def load_config(cls, path: str) -> None:
-    DEFAULT_TO_DATE = os.getenv("DEFAULT_TO_DATE")
+        """Загружает переменные из указанного .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
+    def get_redmine_user(cls) -> str:
+        return os.getenv("REDMINE_USER", "").strip()
+
+    @classmethod
+    def get_redmine_password(cls) -> str:
+        return os.getenv("REDMINE_PASSWORD", "").strip()
+
+    @classmethod
+    def get_redmine_verify(cls) -> Union[bool, str]:
+        value = os.getenv("REDMINE_VERIFY", "").strip()
+        if not value:
+            return DEFAULT_REDMINE_VERIFY
+
+        normalized = value.lower()
+        if normalized in FALSE_VALUES:
+            return False
+        if normalized in TRUE_VALUES:
+            return True
+        return value
 
     @classmethod
     def get_author(cls, cli_author: str = "") -> str:
         """Возвращает автора: из CLI если задан, иначе из .env, иначе — заглушку."""
         if cli_author:
             return cli_author
-        if cls.REDMINE_AUTHOR:
+        return os.getenv("REDMINE_AUTHOR", "").strip()
-            return cls.REDMINE_AUTHOR
-        return ""
 
     @classmethod
     def get_default_date_range(cls) -> str:
-        if cls.DEFAULT_FROM_DATE and cls.DEFAULT_TO_DATE:
+        default_from_date = os.getenv("DEFAULT_FROM_DATE", "").strip()
-            return f"{cls.DEFAULT_FROM_DATE}--{cls.DEFAULT_TO_DATE}"
+        default_to_date = os.getenv("DEFAULT_TO_DATE", "").strip()
-        # fallback hardcoded
+        if default_from_date and default_to_date:
-        return "2025-12-19--2026-01-31"
+            return f"{default_from_date}--{default_to_date}"
+
+        # 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:
-        if not cls.REDMINE_URL:
+        if not cls.get_redmine_url():
             raise ValueError("REDMINE_URL is required (set via env or .env)")
-        if not cls.REDMINE_USER:
+        if cls.get_redmine_api_key():
-            raise ValueError("REDMINE_USER is required")
+            return
-        if not cls.REDMINE_PASSWORD:
+        if not (cls.get_redmine_user() and cls.get_redmine_password()):
-            raise ValueError("REDMINE_PASSWORD is required")
+            raise ValueError(
+                "REDMINE_API_KEY is required, or set both REDMINE_USER and REDMINE_PASSWORD"
+            )

redmine_reporter/formatter.py

@@ -1,30 +0,0 @@
-from typing import List
-from tabulate import tabulate
-from .types import ReportRow
-
-
-def format_compact(rows: List[ReportRow]) -> str:
-    lines = []
-
-    for r in rows:
-        lines.append(
-            f"{r['display_project']} | {r['display_version']} | "
-            f"{r['issue_id']}. {r['subject']} | {r['status_ru']} | {r['time_text']}"
-        )
-
-    return "\n".join(lines)
-
-
-def format_table(rows: List[ReportRow]) -> str:
-    table_rows = [['Проект', 'Версия', 'Задача', 'Статус', 'Затрачено']]
-
-    for r in rows:
-        table_rows.append([
-            r['display_project'],
-            r['display_version'],
-            f"{r['issue_id']}. {r['subject']}",
-            r['status_ru'],
-            r['time_text']
-        ])
-
-    return tabulate(table_rows, headers="firstrow", tablefmt="fancy_grid")

redmine_reporter/formatter_csv.py

@@ -1,22 +0,0 @@
-import csv
-import io
-from typing import List
-from .types import ReportRow
-
-
-def format_csv(rows: List[ReportRow]) -> str:
-    output = io.StringIO()
-    writer = csv.writer(output, dialect="excel")
-    writer.writerow(["Project", "Version", "Issue ID", "Subject", "Status", "Spent Time"])
-
-    for r in rows:
-        writer.writerow([
-            r["project"],
-            r["version"],
-            r["issue_id"],
-            r["subject"],
-            r["status_ru"],
-            r["time_text"]
-        ])
-
-    return output.getvalue()

redmine_reporter/formatter_md.py

@@ -1,19 +0,0 @@
-from typing import List
-from .types import ReportRow
-
-
-def format_md(rows: List[ReportRow]) -> str:
-    lines = [
-        "| Проект | Версия | Задача | Статус | Затрачено |",
-        "|--------|--------|--------|--------|-----------|"
-    ]
-
-    for r in rows:
-        task_cell = f"{r['issue_id']}. {r['subject']}"
-
-        lines.append(
-            f"| {r['display_project']} | {r['display_version']} "
-            f"| {task_cell} | {r['status_ru']} | {r['time_text']} |"
-        )
-
-    return "\n".join(lines)

redmine_reporter/formatter_odt.py

@@ -1,131 +0,0 @@
-import os
-from typing import List
-from odf.opendocument import load
-from odf.text import P
-from odf.table import Table, TableColumn, TableRow, TableCell
-from odf.style import Style, TableColumnProperties, TableCellProperties
-from .types import ReportRow
-from .utils import get_month_name_from_range
-
-
-def format_odt(
-    rows: List[ReportRow],
-    author: str = "",
-    from_date: str = "",
-    to_date: str = "",
-) -> "OpenDocument":
-    template_path = "template.odt"
-    if not os.path.exists(template_path):
-        raise FileNotFoundError("Шаблон template.odt не найден...")
-
-    doc = load(template_path)
-    para_style_name = "Standard"
-
-    # Заголовок
-    month_name = get_month_name_from_range(from_date, to_date)
-    header_text = f"{author}. Отчет за месяц {month_name}."
-    doc.text.addElement(P(stylename=para_style_name, text=header_text))
-    doc.text.addElement(P(stylename=para_style_name, text=""))
-
-    # Стиль ячеек
-    cell_style_name = "TableCellStyle"
-    cell_style = Style(name=cell_style_name, family="table-cell")
-    cell_props = TableCellProperties(padding="0.04in", border="0.05pt solid #000000")
-    cell_style.addElement(cell_props)
-    doc.automaticstyles.addElement(cell_style)
-
-    # Таблица
-    table = Table(name="Report")
-    column_widths = ["1.56in", "1.63in", "3.93in", "1.56in", "1.43in"]
-    for width in column_widths:
-        col_style = Style(name=f"col_{width}", family="table-column")
-        col_props = TableColumnProperties(columnwidth=width)
-        col_style.addElement(col_props)
-        doc.automaticstyles.addElement(col_style)
-        table.addElement(TableColumn(stylename=col_style))
-
-    # Заголовки
-    header_row = TableRow()
-    for text in ["Наименование Проекта", "Номер версии*", "Задача", "Статус Готовность*", "Затрачено за отчетный период"]:
-        cell = TableCell(stylename=cell_style_name)
-        cell.addElement(P(stylename=para_style_name, text=text))
-        header_row.addElement(cell)
-    table.addElement(header_row)
-
-    projects = {}
-    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():
-        total_project_rows = sum(len(rows_for_version) for rows_for_version in versions.values())
-        first_version_in_project = True
-
-        for version, rows_for_version in versions.items():
-            row_span_version = len(rows_for_version)
-            first_row_in_version = True
-
-            for r in rows_for_version:
-                row = TableRow()
-
-                # Ячейка "Проект" - только в первой строке всего проекта
-                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)
-
-                # Ячейка "Версия" - только в первой строке каждой версии
-                if first_row_in_version:
-                    cell_version = TableCell(stylename=cell_style_name)
-                    cell_version.setAttribute("numberrowsspanned", str(row_span_version))
-                    p = P(stylename=para_style_name, text=version)
-                    cell_version.addElement(p)
-                    row.addElement(cell_version)
-                    first_row_in_version = False
-                else:
-                    # Пропускаем - уже объединена
-                    pass
-
-                # Остальные колонки
-                task_cell = TableCell(stylename=cell_style_name)
-                task_text = f"{r['issue_id']}. {r['subject']}"
-                p = P(stylename=para_style_name, text=task_text)
-                task_cell.addElement(p)
-                row.addElement(task_cell)
-
-                status_cell = TableCell(stylename=cell_style_name)
-                p = P(stylename=para_style_name, text=r["status_ru"])
-                status_cell.addElement(p)
-                row.addElement(status_cell)
-
-                time_cell = TableCell(stylename=cell_style_name)
-                p = P(stylename=para_style_name, text=r["time_text"])
-                time_cell.addElement(p)
-                row.addElement(time_cell)
-
-                table.addElement(row)
-                first_version_in_project = False
-
-    doc.text.addElement(table)
-    doc.text.addElement(P(stylename=para_style_name, text=""))
-
-    # Справка
-    for line in [
-        "«Наименование Проекта»  - Имя собственное устройства или программного обеспечения.",
-        "«Номер версии» -  Версия в проекте. Опциональное поле.",
-        "«Задача» -  Номер по Redmine и формулировка.",
-        "«Статус» -  Актуальное состояние задачи на момент отчета. Статусы: закрыто, в работе, ожидание, решена.",
-        "«Готовность» – Опциональное поле в процентах.",
-        "«Затрачено за отчетный период»  - в днях или часах."
-    ]:
-        doc.text.addElement(P(stylename=para_style_name, text=line))
-
-    return doc

redmine_reporter/formatters/base.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+from ..types import ReportRow
+
+
+class Formatter(ABC):
+    """
+    Абстрактный базовый класс для всех форматтеров.
+    Определяет общий интерфейс для форматирования отчета.
+
+    Контракт:
+      - format() возвращает строку для текстовых форматтеров (CSV, HTML, Markdown, console)
+        и объект OpenDocument для ODTFormatter.
+      - save() сохраняет результат в файл; консольные форматтеры бросают NotImplementedError.
+    """
+
+    @abstractmethod
+    def format(self, rows: List[ReportRow]) -> Any:
+        """
+        Форматирует список строк отчета в нужный формат.
+        Для текстовых форматтеров возвращает str.
+        Для ODTFormatter возвращает объект OpenDocument.
+        """
+        pass
+
+    @abstractmethod
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        """
+        Сохраняет отформатированный отчет в файл по указанному пути.
+        Для форматтеров, которые не поддерживают сохранение (например, консольные),
+        бросает NotImplementedError.
+        """
+        pass

redmine_reporter/formatters/console.py

@@ -0,0 +1,47 @@
+from typing import List
+
+from tabulate import tabulate
+
+from ..types import ReportRow
+from .base import Formatter
+
+
+class TableFormatter(Formatter):
+    """Форматтер для вывода красивой таблицы в консоль."""
+
+    def format(self, rows: List[ReportRow]) -> str:
+        table_rows = [["Проект", "Версия", "Задача", "Статус", "Затрачено"]]
+        for r in rows:
+            table_rows.append(
+                [
+                    r["display_project"],
+                    r["display_version"],
+                    f"{r['issue_id']}. {r['subject']}",
+                    r["status_ru"],
+                    r["time_text"],
+                ]
+            )
+        return tabulate(table_rows, headers="firstrow", tablefmt="fancy_grid")
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        # Консольные форматтеры не умеют сохранять в файл напрямую.
+        # Это делается в CLI.
+        raise NotImplementedError("TableFormatter не поддерживает сохранение в файл.")
+
+
+class CompactFormatter(Formatter):
+    """Форматтер для компактного вывода в консоль."""
+
+    def format(self, rows: List[ReportRow]) -> str:
+        lines = []
+        for r in rows:
+            lines.append(
+                f"{r['display_project']} | {r['display_version']} | "
+                f"{r['issue_id']}. {r['subject']} | {r['status_ru']} | {r['time_text']}"
+            )
+        return "\n".join(lines)
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        # Консольные форматтеры не умеют сохранять в файл напрямую.
+        # Это делается в CLI.
+        raise NotImplementedError("CompactFormatter не поддерживает сохранение в файл.")

redmine_reporter/formatters/csv.py

@@ -0,0 +1,41 @@
+import csv
+import io
+from typing import List
+
+from ..types import ReportRow
+from .base import Formatter
+
+
+class CSVFormatter(Formatter):
+    """Форматтер для экспорта в CSV.
+
+    Использует полные значения project/version (а не display-значения с пустыми
+    ячейками для групп). Каждая строка CSV самодостаточна — это корректно для
+    табличного формата (#31). Файл сохраняется в UTF-8 с BOM (utf-8-sig) для
+    корректного отображения кириллицы в Microsoft Excel (#26).
+    """
+
+    def __init__(self, **_kwargs):
+        super().__init__()
+
+    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"])
+        for r in rows:
+            writer.writerow(
+                [
+                    r["project"],
+                    r["version"],
+                    r["issue_id"],
+                    r["subject"],
+                    r["status_ru"],
+                    r["time_text"],
+                ]
+            )
+        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-sig", newline="") as f:
+            f.write(content)

redmine_reporter/formatters/factory.py

@@ -0,0 +1,61 @@
+from typing import Dict, Optional, Type
+
+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 .xlsx import XLSXFormatter
+
+# Словарь для сопоставления расширений файлов с классами форматтеров.
+# ODT и XLSX намеренно отсутствуют — их импорт отложен (ленивый), так как
+# odfpy/openpyxl может быть не установлен. См. get_formatter_by_extension.
+FORMATTER_MAP: Dict[str, Type[Formatter]] = {
+    ".csv": CSVFormatter,
+    ".json": JSONFormatter,
+    ".md": MarkdownFormatter,
+    ".html": HTMLFormatter,
+    ".xlsx": XLSXFormatter,
+}
+
+
+# Словарь для сопоставления типа вывода (консоль) с классами форматтеров
+CONSOLE_FORMATTER_MAP: Dict[str, Type[Formatter]] = {
+    "table": TableFormatter,
+    "compact": CompactFormatter,
+}
+
+
+def get_formatter_by_extension(extension: str, **kwargs) -> Optional[Formatter]:
+    """
+    Возвращает экземпляр форматтера по расширению файла.
+    Ключевые аргументы (**kwargs) передаются в конструктор форматтера.
+    Возвращает None для .odt, если odfpy не установлен.
+    """
+    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
+
+
+def get_console_formatter(formatter_type: str) -> Optional[Formatter]:
+    """
+    Возвращает экземпляр консольного форматтера по его типу.
+    """
+    formatter_class = CONSOLE_FORMATTER_MAP.get(formatter_type.lower())
+    if formatter_class:
+        return formatter_class()
+    return None

redmine_reporter/formatters/html.py

@@ -0,0 +1,85 @@
+from html import escape
+from typing import List
+
+from ..report_builder import group_rows_by_project_and_version
+from ..types import ReportRow
+from .base import Formatter
+
+
+class HTMLFormatter(Formatter):
+    """Форматтер для экспорта отчёта в HTML."""
+
+    def __init__(self, **_kwargs):
+        super().__init__()
+
+    def format(self, rows: List[ReportRow]) -> str:
+        projects = group_rows_by_project_and_version(rows)
+
+        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>",
+            "      <th>Наименование Проекта</th>",
+            "      <th>Номер версии*</th>",
+            "      <th>Задача</th>",
+            "      <th>Статус Готовность*</th>",
+            "      <th>Затрачено за отчетный период</th>",
+            "    </tr>",
+            "  </thead>",
+            "  <tbody>",
+        ]
+
+        for project, versions in projects.items():
+            project_text = escape(project)
+            total_project_rows = sum(len(tasks) for tasks in versions.values())
+            first_version_in_project = True
+
+            for version, task_rows in versions.items():
+                version_text = escape(version)
+                row_span_version = len(task_rows)
+                first_row_in_version = True
+
+                for r in task_rows:
+                    task_cell = escape(f"{r['issue_id']}. {r['subject']}")
+                    status_text = escape(r["status_ru"])
+                    time_text = escape(r["time_text"])
+                    lines.append("    <tr>")
+
+                    # Ячейка "Проект" - только в первой строке проекта
+                    if first_version_in_project and first_row_in_version:
+                        lines.append(
+                            f'      <td rowspan="{total_project_rows}" style="vertical-align: top;">{project_text}</td>'
+                        )
+
+                    # Ячейка "Версия" - только в первой строке версии
+                    if first_row_in_version:
+                        lines.append(
+                            f'      <td rowspan="{row_span_version}" style="vertical-align: top;">{version_text}</td>'
+                        )
+                        first_row_in_version = False
+
+                    # Остальные колонки
+                    lines.append(f"      <td>{task_cell}</td>")
+                    lines.append(f"      <td>{status_text}</td>")
+                    lines.append(f"      <td>{time_text}</td>")
+
+                    lines.append("    </tr>")
+
+                first_version_in_project = False
+
+        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:
+        content = self.format(rows)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(content)

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/markdown.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from ..types import ReportRow
+from .base import Formatter
+
+
+def _escape_markdown_table_cell(value: object) -> str:
+    return str(value).replace("\\", "\\\\").replace("|", "\\|").replace("\n", "<br>")
+
+
+class MarkdownFormatter(Formatter):
+    """Форматтер для экспорта в Markdown."""
+
+    def __init__(self, **_kwargs):
+        super().__init__()
+
+    def format(self, rows: List[ReportRow]) -> str:
+        lines = [
+            "| Проект | Версия | Задача | Статус | Затрачено |",
+            "|--------|--------|--------|--------|-----------|",
+        ]
+        for r in rows:
+            task_cell = _escape_markdown_table_cell(f"{r['issue_id']}. {r['subject']}")
+            lines.append(
+                f"| {_escape_markdown_table_cell(r['display_project'])} "
+                f"| {_escape_markdown_table_cell(r['display_version'])} "
+                f"| {task_cell} "
+                f"| {_escape_markdown_table_cell(r['status_ru'])} "
+                f"| {_escape_markdown_table_cell(r['time_text'])} |"
+            )
+        return "\n".join(lines)
+
+    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

@@ -0,0 +1,157 @@
+from importlib import resources
+from typing import List
+
+from odf.opendocument import OpenDocument, load
+from odf.style import Style, TableCellProperties, TableColumnProperties
+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
+
+
+class ODTFormatter(Formatter):
+    """Форматтер для экспорта в ODT."""
+
+    def __init__(self, author: str = "", from_date: str = "", to_date: str = ""):
+        """
+        Инициализирует форматтер с параметрами для шапки отчета.
+        """
+        self.author = author
+        self.from_date = from_date
+        self.to_date = to_date
+
+    def format(self, rows: List[ReportRow]) -> OpenDocument:
+        """
+        Форматирует данные в объект OpenDocument.
+        """
+
+        with resources.files("redmine_reporter").joinpath("templates/template.odt").open("rb") as f:
+            doc = load(f)
+
+        para_style_name = "Standard"
+
+        # Заголовок
+        month_name = get_month_name_from_range(self.from_date, self.to_date)
+        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=""))
+
+        # Стиль ячеек
+        cell_style_name = "TableCellStyle"
+        cell_style = Style(name=cell_style_name, family="table-cell")
+        cell_props = TableCellProperties(padding="0.04in", border="0.05pt solid #000000")
+        cell_style.addElement(cell_props)
+        doc.automaticstyles.addElement(cell_style)
+
+        # Таблица
+        table = Table(name="Report")
+        column_widths = ["1.56in", "1.63in", "3.93in", "1.56in", "1.43in"]
+        for width in column_widths:
+            col_style = Style(name=f"col_{width}", family="table-column")
+            col_props = TableColumnProperties(columnwidth=width)
+            col_style.addElement(col_props)
+            doc.automaticstyles.addElement(col_style)
+            table.addElement(TableColumn(stylename=col_style))
+
+        # Заголовки
+        header_row = TableRow()
+        for text in [
+            "Наименование Проекта",
+            "Номер версии*",
+            "Задача",
+            "Статус Готовность*",
+            "Затрачено за отчетный период",
+        ]:
+            cell = TableCell(stylename=cell_style_name)
+            cell.addElement(P(stylename=para_style_name, text=text))
+            header_row.addElement(cell)
+        table.addElement(header_row)
+
+        projects = group_rows_by_project_and_version(rows)
+
+        # Данные с двухуровневой группировкой и объединением ячеек
+        for project, versions in projects.items():
+            total_project_rows = sum(
+                len(rows_for_version) for rows_for_version in versions.values()
+            )
+            first_version_in_project = True
+
+            for version, rows_for_version in versions.items():
+                row_span_version = len(rows_for_version)
+                first_row_in_version = True
+
+                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))
+                        p = P(stylename=para_style_name, text=version)
+                        cell_version.addElement(p)
+                        row.addElement(cell_version)
+                        first_row_in_version = False
+                    else:
+                        row.addElement(CoveredTableCell())
+
+                    # Остальные колонки
+                    task_cell = TableCell(stylename=cell_style_name)
+                    task_text = f"{r['issue_id']}. {r['subject']}"
+                    p = P(stylename=para_style_name, text=task_text)
+                    task_cell.addElement(p)
+                    row.addElement(task_cell)
+
+                    status_cell = TableCell(stylename=cell_style_name)
+                    p = P(stylename=para_style_name, text=r["status_ru"])
+                    status_cell.addElement(p)
+                    row.addElement(status_cell)
+
+                    time_cell = TableCell(stylename=cell_style_name)
+                    p = P(stylename=para_style_name, text=r["time_text"])
+                    time_cell.addElement(p)
+                    row.addElement(time_cell)
+
+                    table.addElement(row)
+
+                first_version_in_project = False
+
+        doc.text.addElement(table)
+        doc.text.addElement(P(stylename=para_style_name, text=""))
+
+        # Справка
+        for line in [
+            "«Наименование Проекта»  - Имя собственное устройства или программного обеспечения.",
+            "«Номер версии» -  Версия в проекте. Опциональное поле.",
+            "«Задача» -  Номер по Redmine и формулировка.",
+            "«Статус» -  Актуальное состояние задачи на момент отчета. Статусы: закрыто, в работе, ожидание, решена.",
+            "«Готовность» – Опциональное поле в процентах.",
+            "«Затрачено за отчетный период»  - в днях или часах.",
+        ]:
+            doc.text.addElement(P(stylename=para_style_name, text=line))
+
+        return doc
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        """
+        Сохраняет сформированный документ в файл.
+        """
+        doc = self.format(rows)
+        doc.save(output_path)

redmine_reporter/formatters/xlsx.py

@@ -0,0 +1,42 @@
+from typing import List
+
+from openpyxl import Workbook
+from openpyxl.styles import Font
+
+from ..types import ReportRow
+from .base import Formatter
+
+
+class XLSXFormatter(Formatter):
+    """Форматтер для экспорта отчёта в Excel (.xlsx)."""
+
+    def __init__(self, **_kwargs):
+        super().__init__()
+
+    def format(self, rows: List[ReportRow]) -> Workbook:
+        wb = Workbook()
+        ws = wb.active
+        ws.title = "Report"
+
+        headers = ["Project", "Version", "Issue ID", "Subject", "Status", "Spent Time"]
+        ws.append(headers)
+        for cell in ws[1]:
+            cell.font = Font(bold=True)
+
+        for r in rows:
+            ws.append(
+                [
+                    r["project"],
+                    r["version"],
+                    r["issue_id"],
+                    r["subject"],
+                    r["status_ru"],
+                    r["time_text"],
+                ]
+            )
+
+        return wb
+
+    def save(self, rows: List[ReportRow], output_path: str) -> None:
+        wb = self.format(rows)
+        wb.save(output_path)

redmine_reporter/report_builder.py

@@ -1,19 +1,24 @@
-from typing import List, Tuple, cast
+from typing import Dict, List, Tuple, cast
+
 from redminelib.resources import Issue
+
 from .types import ReportRow
 from .utils import get_version, hours_to_human
 
-
 STATUS_TRANSLATION = {
-    'Closed': 'Закрыто',
+    "New": "В работе",
-    'Re-opened': 'В работе',
+    "In Progress": "В работе",
-    'New': 'В работе',
+    "Feedback": "В работе",
-    'Resolved': 'Решена',
+    "Re-opened": "В работе",
-    'Pending': 'Ожидание',
+    "Code Review": "Решена",
-    'Feedback': 'В работе',
+    "Wait Release": "Закрыто",
-    'In Progress': 'В работе',
+    "Pending": "Ожидание",
-    'Rejected': 'Закрыто',
+    "Resolved": "Решена",
-    'Confirming': 'Ожидание',
+    "Testing": "Решена",
+    "Confirming": "Ожидание",
+    "Closed": "Закрыто",
+    "Rejected": "Закрыто",
+    "Frozen": "Ожидание",
 }
 
 
@@ -24,8 +29,14 @@ def build_grouped_report(
     """
     Преобразует список задач с затраченным временем в плоский список строк отчёта,
     с учётом группировки по проекту и версии (пустые ячейки для повторяющихся значений).
+
+    Предусловие: issue_hours должен быть отсортирован по (project, version).
+    Функция выполняет сортировку самостоятельно для защиты от несортированного ввода.
     """
 
+    # Защитная сортировка -- гарантирует корректную группировку независимо от порядка на входе
+    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 = ""
     prev_version: str = ""
@@ -52,6 +63,7 @@ def build_grouped_report(
                     "subject": issue.subject,
                     "status_ru": status_ru,
                     "time_text": time_text,
+                    "hours": round(hours, 2),
                 },
             )
         )
@@ -60,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

@@ -10,8 +10,19 @@ def get_month_name_from_range(from_date: str, to_date: str) -> str:
         return "Январь"
 
     months = [
-        "", "Январь", "Февраль", "Март", "Апрель", "Май", "Июнь",
+        "",
-        "Июль", "Август", "Сентябрь", "Октябрь", "Ноябрь", "Декабрь"
+        "Январь",
+        "Февраль",
+        "Март",
+        "Апрель",
+        "Май",
+        "Июнь",
+        "Июль",
+        "Август",
+        "Сентябрь",
+        "Октябрь",
+        "Ноябрь",
+        "Декабрь",
     ]
 
     return months[end.month]
@@ -19,7 +30,11 @@ def get_month_name_from_range(from_date: str, to_date: str) -> str:
 
 def get_version(issue) -> str:
     """Возвращает версию задачи или '<N/A>', если не задана."""
-    return str(getattr(issue, 'fixed_version', '<N/A>'))
+    version = getattr(issue, "fixed_version", None)
+    if version is None:
+        return "<N/A>"
+    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,20 +1,210 @@
+import os
+from unittest import mock
+
 import pytest
-from redmine_reporter.cli import parse_date_range
+
+from redmine_reporter.cli import main, parse_date_range
+
+VALID_ENV = {
+    "REDMINE_URL": "https://red.eltex.loc",
+    "REDMINE_API_KEY": "token",
+}
 
 
-def test_parse_date_range_valid():
+@pytest.fixture(autouse=True)
-    assert parse_date_range("2025-01-01--2025-12-31") == ("2025-01-01", "2025-12-31")
+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("")
 
 
-def test_parse_date_range_with_spaces():
+@pytest.mark.parametrize(
-    assert parse_date_range("2025-01-01 -- 2025-12-31") == ("2025-01-01", "2025-12-31")
+    "date_arg, expected",
+    [
+        ("2026-01-01--2026-01-31", ("2026-01-01", "2026-01-31")),
+        (" 2026-01-01 -- 2026-01-31 ", ("2026-01-01", "2026-01-31")),
+    ],
+)
+def test_parse_date_range_valid(date_arg, expected):
+    assert parse_date_range(date_arg) == expected
 
 
-def test_parse_date_range_invalid_no_separator():
+@pytest.mark.parametrize(
-    with pytest.raises(ValueError, match="must be in format"):
+    "date_arg",
-        parse_date_range("2025-01-01")
+    [
+        "20260101-20260131",
+        "2026-1-01--2026-01-31",
+        "2026-02-30--2026-03-01",
+        "2026-02-01--2026-01-31",
+    ],
+)
+def test_parse_date_range_invalid(date_arg):
+    with pytest.raises(ValueError):
+        parse_date_range(date_arg)
 
 
-def test_parse_date_range_invalid_parts():
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
-    with pytest.raises(ValueError, match="Invalid date range format"):
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
-        parse_date_range("2025-01-01--")
+def test_cli_returns_zero_on_no_entries(mock_fetch):
+    """None от fetch (нет time entries) -- выход 0."""
+    mock_fetch.return_value = None
+    code = main(["--date", "2026-01-01--2026-01-31"])
+    assert code == 0
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_cli_config_error():
+    """Невалидный конфиг -- выход 1."""
+    code = main(["--date", "2026-01-01--2026-01-31"])
+    assert code == 1
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+def test_cli_invalid_date_format():
+    """Неверный формат даты -- выход 1."""
+    code = main(["--date", "20260101-20260131"])
+    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."""
+    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
+
+
+@mock.patch.dict(os.environ, VALID_ENV, clear=True)
+@mock.patch("redmine_reporter.cli.fetch_issues_with_spent_time")
+def test_cli_output_without_extension(mock_fetch, tmp_path):
+    """Файл без расширения -- выход 1 с подсказкой."""
+    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

tests/test_client.py

@@ -0,0 +1,250 @@
+import os
+from unittest import mock
+
+from redmine_reporter.client import fetch_issues_with_spent_time
+from redmine_reporter.config import DEFAULT_REDMINE_VERIFY
+
+PASSWORD_ENV = {
+    "REDMINE_URL": "https://red.eltex.loc",
+    "REDMINE_USER": "user",
+    "REDMINE_PASSWORD": "password",
+}
+
+
+def _configure_current_user(mock_redmine, user_id=1):
+    mock_user = mock.MagicMock()
+    mock_user.id = user_id
+    mock_redmine.user.get.return_value = mock_user
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_aggregates_hours_per_issue(mock_redmine_class):
+    """Два time entry на одну задачу -- часы суммируются."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine, user_id=123)
+
+    mock_entry1 = mock.MagicMock()
+    mock_entry1.issue.id = 101
+    mock_entry1.hours = 2.0
+    mock_entry2 = mock.MagicMock()
+    mock_entry2.issue.id = 101
+    mock_entry2.hours = 1.5
+    mock_redmine.time_entry.filter.return_value = [mock_entry1, mock_entry2]
+
+    mock_issue = mock.MagicMock()
+    mock_issue.id = 101
+    mock_issue.project = "Проект X"
+    mock_issue.subject = "Тестовая задача"
+    mock_issue.status = "New"
+    mock_redmine.issue.filter.return_value = [mock_issue]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+
+    assert result is not None
+    assert len(result) == 1
+    issue, total_hours = result[0]
+    assert total_hours == 3.5
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_returns_none_when_no_entries(mock_redmine_class):
+    """Нет time entries -- возвращается None."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+    mock_redmine.time_entry.filter.return_value = []
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+    assert result is None
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_skips_entries_without_issue(mock_redmine_class):
+    """Time entry без привязки к задаче игнорируется."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    # entry без issue атрибута
+    entry_no_issue = mock.MagicMock(spec=["hours"])  # нет .issue
+    entry_no_issue.hours = 1.0
+
+    mock_redmine.time_entry.filter.return_value = [entry_no_issue]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+    assert result is None
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_multiple_issues(mock_redmine_class):
+    """Несколько задач -- каждая с правильным суммарным временем."""
+    mock_redmine = mock_redmine_class.return_value
+    _configure_current_user(mock_redmine)
+
+    def make_entry(issue_id, hours):
+        e = mock.MagicMock()
+        e.issue.id = issue_id
+        e.hours = hours
+        return e
+
+    mock_redmine.time_entry.filter.return_value = [
+        make_entry(1, 1.0),
+        make_entry(2, 2.0),
+        make_entry(1, 0.5),
+    ]
+
+    mock_issue1 = mock.MagicMock()
+    mock_issue1.id = 1
+    mock_issue1.project = "P"
+    mock_issue2 = mock.MagicMock()
+    mock_issue2.id = 2
+    mock_issue2.project = "P"
+    mock_redmine.issue.filter.return_value = [mock_issue1, mock_issue2]
+
+    result = fetch_issues_with_spent_time("2026-01-01", "2026-01-31")
+    assert result is not None
+    assert len(result) == 2
+
+    hours_by_id = {issue.id: hours for issue, hours in result}
+    assert hours_by_id[1] == 1.5
+    assert hours_by_id[2] == 2.0
+
+
+@mock.patch.dict(
+    os.environ,
+    {
+        "REDMINE_URL": "https://red.eltex.loc",
+        "REDMINE_API_KEY": "api-token",
+        "REDMINE_USER": "user",
+        "REDMINE_PASSWORD": "password",
+    },
+    clear=True,
+)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_uses_api_key_when_present(mock_redmine_class):
+    """Если задан API key, он используется вместо логина/пароля."""
+    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 kwargs["key"] == "api-token"
+    assert kwargs["requests"]["verify"] == DEFAULT_REDMINE_VERIFY
+    assert "username" not in kwargs
+    assert "password" not in kwargs
+
+
+@mock.patch.dict(os.environ, PASSWORD_ENV, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_uses_username_password_when_no_api_key(mock_redmine_class):
+    """Если API key не задан, остаётся старая схема логин/пароль."""
+    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 kwargs["username"] == "user"
+    assert kwargs["password"] == "password"
+    assert kwargs["requests"]["verify"] == DEFAULT_REDMINE_VERIFY
+    assert "key" not in kwargs
+
+
+@mock.patch.dict(os.environ, {**PASSWORD_ENV, "REDMINE_VERIFY": "/tmp/redmine-ca.pem"}, clear=True)
+@mock.patch("redmine_reporter.client.Redmine")
+def test_fetch_uses_custom_verify_path(mock_redmine_class):
+    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 kwargs["requests"]["verify"] == "/tmp/redmine-ca.pem"
+
+
+# -- #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

@@ -0,0 +1,135 @@
+import os
+from unittest import mock
+
+import pytest
+
+from redmine_reporter.config import DEFAULT_REDMINE_VERIFY, Config
+
+
+@mock.patch.dict(
+    os.environ,
+    {
+        "REDMINE_URL": "https://red.eltex.loc/",
+        "REDMINE_USER": "test",
+        "REDMINE_PASSWORD": "secret",
+    },
+    clear=True,
+)
+def test_config_valid_with_password_fallback():
+    Config.validate()  # не должно быть исключения
+
+
+@mock.patch.dict(
+    os.environ,
+    {
+        "REDMINE_URL": "https://red.eltex.loc/",
+        "REDMINE_API_KEY": "token",
+    },
+    clear=True,
+)
+def test_config_valid_with_api_key():
+    Config.validate()  # не должно быть исключения
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_config_missing_url():
+    with pytest.raises(ValueError, match="REDMINE_URL"):
+        Config.validate()
+
+
+@mock.patch.dict(os.environ, {"REDMINE_URL": "https://red.eltex.loc/"}, clear=True)
+def test_config_missing_auth():
+    with pytest.raises(ValueError, match="REDMINE_API_KEY"):
+        Config.validate()
+
+
+@mock.patch.dict(os.environ, {"REDMINE_URL": " https://red.eltex.loc/ "}, clear=True)
+def test_get_redmine_url_strips_spaces_and_trailing_slash():
+    assert Config.get_redmine_url() == "https://red.eltex.loc"
+
+
+@mock.patch.dict(os.environ, {"REDMINE_AUTHOR": " Иванов И.И. "}, clear=True)
+def test_get_author():
+    assert Config.get_author("") == "Иванов И.И."
+    assert Config.get_author("Петров П.П.") == "Петров П.П."
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_get_author_fallback():
+    """Если ни CLI, ни .env не задали автора -- возвращается пустая строка."""
+    assert Config.get_author("") == ""
+
+
+@mock.patch.dict(
+    os.environ,
+    {
+        "DEFAULT_FROM_DATE": "2026-01-01",
+        "DEFAULT_TO_DATE": "2026-01-31",
+    },
+    clear=True,
+)
+def test_get_default_date_range_from_env():
+    assert Config.get_default_date_range() == "2026-01-01--2026-01-31"
+
+
+@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 result == f"{start.isoformat()}--{end.isoformat()}"
+
+
+@mock.patch.dict(os.environ, {}, clear=True)
+def test_get_redmine_verify_default():
+    assert Config.get_redmine_verify() == DEFAULT_REDMINE_VERIFY
+
+
+@pytest.mark.parametrize("value", ["0", "false", "False", "no", "off"])
+def test_get_redmine_verify_false_values(value):
+    with mock.patch.dict(os.environ, {"REDMINE_VERIFY": value}, clear=True):
+        assert Config.get_redmine_verify() is False
+
+
+@pytest.mark.parametrize("value", ["1", "true", "True", "yes", "on"])
+def test_get_redmine_verify_true_values(value):
+    with mock.patch.dict(os.environ, {"REDMINE_VERIFY": value}, clear=True):
+        assert Config.get_redmine_verify() is True
+
+
+@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_formatter_odt.py

@@ -1,73 +0,0 @@
-import tempfile
-from types import SimpleNamespace
-from redmine_reporter.formatter_odt import format_odt
-
-
-def make_mock_issue(id_, project, subject, status, fixed_version=None):
-    """Создаёт лёгкий mock-объект, имитирующий Issue из redminelib."""
-
-    issue = SimpleNamespace()
-    issue.id = id_
-    issue.project = project
-    issue.subject = subject
-    issue.status = status
-
-    if fixed_version is not None:
-        issue.fixed_version = fixed_version
-    return issue
-
-
-def test_format_odt_basic():
-    issues = [
-        (make_mock_issue(101, "Камеры", "Поддержка нового датчика", "In Progress", "v2.5.0"), 2.5),
-        (make_mock_issue(102, "Камеры", "Исправить утечку памяти", "Resolved", "v2.5.0"), 4.0),
-        (make_mock_issue(103, "ПО", "Обновить документацию", "Pending", None), 12.0),
-    ]
-
-    doc = format_odt(issues)
-
-    # Сохраняем и проверяем содержимое
-    with tempfile.NamedTemporaryFile(suffix=".odt") as tmp:
-        doc.save(tmp.name)
-
-        # Проверяем, что файл - это ZIP (ODT основан на ZIP)
-        with open(tmp.name, "rb") as f:
-            assert f.read(2) == b"PK"
-
-        # Извлекаем content.xml
-        import zipfile
-        with zipfile.ZipFile(tmp.name) as zf:
-            content_xml = zf.read("content.xml").decode("utf-8")
-
-        # Проверяем заголовки
-        assert "Проект" in content_xml
-        assert "Версия" in content_xml
-        assert "Задача" in content_xml
-        assert "Статус" in content_xml
-        assert "Затрачено" in content_xml
-
-        # Проверяем данные задач
-        assert "101. Поддержка нового датчика" in content_xml
-        assert "102. Исправить утечку памяти" in content_xml
-        assert "103. Обновить документацию" in content_xml
-
-        # Проверяем проекты и версии
-        assert "Камеры" in content_xml
-        assert "ПО" in content_xml
-        assert "v2.5.0" in content_xml
-        assert "&lt;N/A&gt;" in content_xml or "<N/A>" in content_xml  # зависит от экранирования
-
-        # Проверяем перевод статусов
-        assert "В работе" in content_xml   # In Progress
-        assert "Решена" in content_xml     # Resolved
-        assert "Ожидание" in content_xml   # Pending
-
-        # Проверяем формат времени
-        assert "2ч 30м" in content_xml
-        assert "4ч" in content_xml
-        assert "12ч" in content_xml
-
-        # Проверяем группировку: "Камеры" должен встречаться только один раз явно
-        # (вторая строка — пустая ячейка)
-        cam_occurrences = content_xml.count(">Камеры<")
-        assert cam_occurrences == 1

tests/test_formatters.py

@@ -0,0 +1,473 @@
+import io
+import json
+from typing import List
+from unittest import mock
+
+import pytest
+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
+
+
+def _make_empty_odt_bytes() -> bytes:
+    """Создаёт минимальный валидный ODT-документ в памяти."""
+    doc = OpenDocumentText()
+    buf = io.BytesIO()
+    doc.save(buf)
+    return buf.getvalue()
+
+
+def make_fake_report_rows() -> List[ReportRow]:
+    """
+    Генерирует фейковый отчёт с полным покрытием логики группировки:
+    - Проект A: версия v1.0 (2 задачи), версия v2.0 (1 задача)
+    - Проект B: версия <N/A> (1 задача)
+    - Проект C: версия v1.0 (1 задача), версия v1.1 (2 задачи)
+    """
+    return [
+        {
+            "project": "Проект A",
+            "version": "v1.0",
+            "display_project": "Проект A",
+            "display_version": "v1.0",
+            "issue_id": 101,
+            "subject": "Реализовать фичу X",
+            "status_ru": "В работе",
+            "time_text": "4ч 30м",
+        },
+        {
+            "project": "Проект A",
+            "version": "v1.0",
+            "display_project": "",
+            "display_version": "",
+            "issue_id": 102,
+            "subject": "Исправить баг Y",
+            "status_ru": "Решена",
+            "time_text": "2ч",
+        },
+        {
+            "project": "Проект A",
+            "version": "v2.0",
+            "display_project": "",
+            "display_version": "v2.0",
+            "issue_id": 103,
+            "subject": "Документация Z",
+            "status_ru": "Ожидание",
+            "time_text": "1ч",
+        },
+        {
+            "project": "Проект B",
+            "version": "<N/A>",
+            "display_project": "Проект B",
+            "display_version": "<N/A>",
+            "issue_id": 201,
+            "subject": "Обновить README",
+            "status_ru": "Закрыто",
+            "time_text": "0ч",
+        },
+        {
+            "project": "Проект C",
+            "version": "v1.0",
+            "display_project": "Проект C",
+            "display_version": "v1.0",
+            "issue_id": 301,
+            "subject": "Настроить CI",
+            "status_ru": "В работе",
+            "time_text": "3ч 15м",
+        },
+        {
+            "project": "Проект C",
+            "version": "v1.1",
+            "display_project": "",
+            "display_version": "v1.1",
+            "issue_id": 302,
+            "subject": "Добавить тесты",
+            "status_ru": "В работе",
+            "time_text": "5ч",
+        },
+        {
+            "project": "Проект C",
+            "version": "v1.1",
+            "display_project": "",
+            "display_version": "",
+            "issue_id": 303,
+            "subject": "Рефакторинг",
+            "status_ru": "Решена",
+            "time_text": "6ч 45м",
+        },
+    ]
+
+
+@pytest.fixture
+def fake_rows():
+    return make_fake_report_rows()
+
+
+@pytest.fixture
+def odt_formatter():
+    """ODTFormatter с замоканной загрузкой шаблона."""
+    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))
+            )
+        ),
+    ):
+        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()),
+]
+
+
+@pytest.mark.parametrize("name, factory", TEXT_FORMATTER_FACTORIES)
+def test_text_formatter_returns_nonempty_string(fake_rows, name, factory):
+    """Текстовые форматтеры возвращают непустую строку."""
+    result = factory().format(fake_rows)
+    assert isinstance(result, str)
+    assert len(result.strip()) > 0
+
+
+@pytest.mark.parametrize("name, factory", TEXT_FORMATTER_FACTORIES)
+def test_text_formatter_contains_key_content(fake_rows, name, factory):
+    """Вывод содержит ключевые данные из отчёта."""
+    output = factory().format(fake_rows)
+
+    assert "Проект A" in output
+    assert "Проект B" in output
+    assert "В работе" in output
+    assert "<N/A>" in output
+    assert "6ч 45м" in output
+
+    if name == "csv":
+        # В 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
+
+
+@pytest.mark.parametrize("name, factory", TEXT_FORMATTER_FACTORIES)
+def test_text_formatter_empty_rows(name, factory):
+    """Форматтер не падает на пустом списке строк."""
+    result = factory().format([])
+    assert isinstance(result, str)
+
+
+# -- Тесты консольных форматтеров --
+
+
+def test_table_formatter_save_raises(fake_rows):
+    with pytest.raises(NotImplementedError):
+        TableFormatter().save(fake_rows, "/dev/null")
+
+
+def test_compact_formatter_save_raises(fake_rows):
+    with pytest.raises(NotImplementedError):
+        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.max_row == len(fake_rows) + 1  # header + data
+
+
+def test_markdown_formatter_escapes_table_cells():
+    rows = make_fake_report_rows()
+    rows[0]["project"] = "A|B"
+    rows[0]["display_project"] = "A|B"
+    rows[0]["subject"] = "Fix | split\nline"
+
+    output = MarkdownFormatter().format(rows)
+
+    assert "A\\|B" in output
+    assert "101. Fix \\| split<br>line" in output
+
+
+def test_html_formatter_escapes_cells():
+    rows = make_fake_report_rows()
+    rows[0]["project"] = 'A&B "<Project>"'
+    rows[0]["display_project"] = rows[0]["project"]
+    rows[0]["subject"] = "Fix <tag> & attrs"
+
+    output = HTMLFormatter().format(rows)
+
+    assert "A&amp;B &quot;&lt;Project&gt;&quot;" in output
+    assert "101. Fix &lt;tag&gt; &amp; attrs" in output
+    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 форматтера --
+
+
+def test_odt_formatter_returns_opendocument(fake_rows, odt_formatter):
+    """ODTFormatter.format() возвращает объект OpenDocument."""
+    result = odt_formatter.format(fake_rows)
+    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()
+    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")
+        output_file = tmp_path / "report.odt"
+        formatter.save(fake_rows, str(output_file))
+
+    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

@@ -0,0 +1,279 @@
+from redmine_reporter.report_builder import (
+    STATUS_TRANSLATION,
+    build_grouped_report,
+    calculate_summary,
+    group_rows_by_project_and_version,
+)
+
+
+class MockIssue:
+    def __init__(self, project, subject, status, fixed_version=None, issue_id=999):
+        self.id = issue_id
+        self.project = project
+        self.subject = subject
+        self.status = status
+        if fixed_version is not None:
+            self.fixed_version = fixed_version
+
+
+# -- Таблица переводов статусов --
+
+
+def test_status_translation():
+    assert STATUS_TRANSLATION["Closed"] == "Закрыто"
+    assert STATUS_TRANSLATION["New"] == "В работе"
+    assert STATUS_TRANSLATION["Resolved"] == "Решена"
+    assert STATUS_TRANSLATION["Pending"] == "Ожидание"
+
+
+def test_status_translation_unknown_passthrough():
+    """Неизвестный статус возвращается как есть."""
+    from redmine_reporter.report_builder import STATUS_TRANSLATION
+
+    assert "SomeNewStatus" not in STATUS_TRANSLATION
+    # build_grouped_report вернёт оригинальное значение
+    issue = MockIssue("P", "S", "SomeNewStatus", "v1.0", 1)
+    rows = build_grouped_report([(issue, 1.0)])
+    assert rows[0]["status_ru"] == "SomeNewStatus"
+
+
+# -- Основная логика группировки --
+
+
+def test_build_grouped_report_grouping():
+    issues = [
+        (MockIssue("Камеры", "Фича A", "New", "v2.5.0", 101), 2.0),
+        (MockIssue("Камеры", "Баг B", "Resolved", "v2.5.0", 102), 1.5),
+        (MockIssue("ПО", "Доки", "Pending", None, 201), 4.0),
+    ]
+    rows = build_grouped_report(issues)
+
+    assert len(rows) == 3
+    # Первая строка -- полное название проекта и версии
+    assert rows[0]["display_project"] == "Камеры"
+    assert rows[0]["display_version"] == "v2.5.0"
+    # Вторая -- пустые display_* из-за совпадения проекта+версии
+    assert rows[1]["display_project"] == ""
+    assert rows[1]["display_version"] == ""
+    # Третья -- новый проект
+    assert rows[2]["display_project"] == "ПО"
+    assert rows[2]["display_version"] == "<N/A>"
+
+    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():
+    """Смена версии внутри одного проекта -- display_project пустой, display_version новая."""
+    issues = [
+        (MockIssue("Камеры", "Задача 1", "New", "v1.0", 1), 1.0),
+        (MockIssue("Камеры", "Задача 2", "New", "v2.0", 2), 1.0),
+    ]
+    rows = build_grouped_report(issues)
+    assert rows[0]["display_project"] == "Камеры"
+    assert rows[0]["display_version"] == "v1.0"
+    assert rows[1]["display_project"] == ""
+    assert rows[1]["display_version"] == "v2.0"
+
+
+def test_build_grouped_report_sorts_input():
+    """Несортированный вход -- результат всё равно корректно сгруппирован."""
+    issues = [
+        (MockIssue("ПО", "Задача B", "New", "v1.0", 2), 1.0),
+        (MockIssue("Камеры", "Задача A", "New", "v1.0", 1), 2.0),
+    ]
+    rows = build_grouped_report(issues)
+    # После сортировки "Камеры" < "ПО" (лексикографически по кириллице)
+    assert rows[0]["project"] == "Камеры"
+    assert rows[1]["project"] == "ПО"
+    # Оба display_project непустые -- разные проекты
+    assert rows[0]["display_project"] == "Камеры"
+    assert rows[1]["display_project"] == "ПО"
+
+
+def test_build_grouped_report_empty():
+    """Пустой вход -- пустой результат, без исключений."""
+    rows = build_grouped_report([])
+    assert rows == []
+
+
+def test_build_grouped_report_no_time():
+    """fill_time=False -- time_text пустой для всех строк."""
+    issues = [(MockIssue("P", "S", "New", "v1.0", 1), 3.5)]
+    rows = build_grouped_report(issues, fill_time=False)
+    assert rows[0]["time_text"] == ""
+
+
+def test_build_grouped_report_preserves_issue_id_and_subject():
+    issues = [(MockIssue("P", "Моя задача", "Closed", "v1.0", 42), 0.5)]
+    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

@@ -0,0 +1,112 @@
+from redmine_reporter.utils import (
+    get_month_name_from_range,
+    get_version,
+    hours_to_human,
+)
+
+
+def test_hours_to_human_zero():
+    assert hours_to_human(0) == "0ч"
+    assert hours_to_human(-1) == "0ч"
+
+
+def test_hours_to_human_whole_hours():
+    assert hours_to_human(1.0) == "1ч"
+    assert hours_to_human(8.0) == "8ч"
+
+
+def test_hours_to_human_minutes_only():
+    assert hours_to_human(0.75) == "45м"
+    assert hours_to_human(0.5) == "30м"
+
+
+def test_hours_to_human_mixed():
+    assert hours_to_human(2.5) == "2ч 30м"
+    assert hours_to_human(1.5) == "1ч 30м"
+
+
+def test_hours_to_human_rounding():
+    assert hours_to_human(3.1666) == "3ч 10м"  # 190 минут -> 3ч 10м
+
+
+def test_get_month_name_from_range():
+    assert get_month_name_from_range("2026-01-01", "2026-01-31") == "Январь"
+    assert get_month_name_from_range("2025-12-01", "2026-02-15") == "Февраль"
+
+
+def test_get_month_name_from_range_all_months():
+    months = [
+        "Январь",
+        "Февраль",
+        "Март",
+        "Апрель",
+        "Май",
+        "Июнь",
+        "Июль",
+        "Август",
+        "Сентябрь",
+        "Октябрь",
+        "Ноябрь",
+        "Декабрь",
+    ]
+    for i, name in enumerate(months, start=1):
+        to_date = f"2026-{i:02d}-01"
+        assert get_month_name_from_range("2026-01-01", to_date) == name
+
+
+def test_get_month_name_from_range_invalid_fallback():
+    """Невалидная дата -- возвращается 'Январь'."""
+    assert get_month_name_from_range("invalid", "also_invalid") == "Январь"
+
+
+def test_get_version_with_attribute():
+    class MockIssue:
+        fixed_version = "v2.5.0"
+
+    assert get_version(MockIssue()) == "v2.5.0"
+
+
+def test_get_version_without_attribute():
+    class MockIssue:
+        pass
+
+    assert get_version(MockIssue()) == "<N/A>"
+
+
+def test_get_version_none_attribute():
+    class MockIssue:
+        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"