redmine-reporter/tests/test_client.py

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