api/src/test/java/com/spendtracker/service/ReportServiceTest.java - master - berkas/Spend-tracker

api/src/test/java/com/spendtracker/service/ReportServiceTest.java
138 строк5 KB
akasianov
Created tests for getPeriodCompareReport and getNominalTotal
15 янв 2026, 10:08
15 янв 2026, 10:086552751
package com.spendtracker.application.service;

import com.spendtracker.application.dto.PeriodReportDto;
import com.spendtracker.domain.InflationRate;
import com.spendtracker.domain.Transaction;
import com.spendtracker.repository.InflationRateRepository;
import com.spendtracker.repository.TransactionRepository;
import com.spendtracker.repository.filter.TransactionFilter;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;

class ReportServiceTest {

    private TransactionRepository transactionRepository;
    private InflationRateRepository inflationRateRepository;
    private ReportService reportService;

    @BeforeEach
    void setUp() {
        transactionRepository = mock(TransactionRepository.class);
        inflationRateRepository = mock(InflationRateRepository.class);
        reportService = new ReportService(
                transactionRepository,
                inflationRateRepository
        );
    }

    @Test
    void calculateInflationIndex_multiplies_monthly_rates() {
        when(inflationRateRepository.findAllByStartAndEndDates(2022, 2022))
                .thenReturn(List.of(
                        new InflationRate(2022, 2, new BigDecimal("0.02")),
                        new InflationRate(2022, 3, new BigDecimal("0.01"))
                ));

        BigDecimal index = reportService.calculateInflationIndex(
                YearMonth.of(2022, 1),
                YearMonth.of(2022, 3)
        );

        assertThat(index).isEqualByComparingTo("1.0302");
    }

    @Test
    void getPeriodReport_returns_nominal_and_real_totals() {
        when(transactionRepository.findAll(any(TransactionFilter.class)))
                .thenReturn(List.of(
                        transaction(
                                "INCOME",
                                "1000",
                                LocalDateTime.of(2022, 1, 10, 0, 0)
                        ),
                        transaction(
                                "EXPENSE",
                                "400",
                                LocalDateTime.of(2022, 1, 15, 0, 0)
                        )
                ));

        when(inflationRateRepository.findAllByStartAndEndDates(2022, 2022))
                .thenReturn(List.of(
                        new InflationRate(2022, 2, new BigDecimal("0.05"))
                ));

        PeriodReportDto report = reportService.getPeriodReport(
                "user-1",
                YearMonth.of(2022, 1),
                YearMonth.of(2022, 2)
        );

        assertThat(report.getNominalIncome())
                .isEqualByComparingTo("1000");

        assertThat(report.getNominalExpense())
                .isEqualByComparingTo("400");

        assertThat(report.getRealIncome())
                .isEqualByComparingTo("1050.00");

        assertThat(report.getRealExpense())
                .isEqualByComparingTo("420.00");

        verify(transactionRepository).findAll(any(TransactionFilter.class));
        verify(inflationRateRepository).findAllByStartAndEndDates(2022, 2022);
    }

    @Test
    void getPeriodReport_builds_correct_transaction_filter() {
        when(transactionRepository.findAll(any()))
                .thenReturn(List.of());

        when(inflationRateRepository.findAllByStartAndEndDates(anyInt(), anyInt()))
                .thenReturn(List.of());

        reportService.getPeriodReport(
                "admin",
                YearMonth.of(2023, 3),
                YearMonth.of(2023, 4)
        );

        ArgumentCaptor<TransactionFilter> captor =
                ArgumentCaptor.forClass(TransactionFilter.class);

        verify(transactionRepository).findAll(captor.capture());

        TransactionFilter filter = captor.getValue();

        assertThat(filter.getUserIds()).containsExactly("admin");
        assertThat(filter.getStart())
                .isEqualTo(LocalDateTime.of(2023, 3, 1, 0, 0));
        assertThat(filter.getEnd())
                .isEqualTo(LocalDateTime.of(2023, 4, 30, 23, 59, 59));
    }

    private Transaction transaction(
            String type,
            String amount,
            LocalDateTime date
    ) {
        return new Transaction(
                "tx-id",
                "user-id",
                "category-id",
                new BigDecimal(amount),
                type,
                date
        );
    }
}