magistr/backend/src/test/java/com/magistr/app/controller/AcademicCalendarControllerTest.java

package com.magistr.app.controller;

import com.magistr.app.dto.AcademicCalendarDto;
import com.magistr.app.dto.AcademicCalendarGridDayDto;
import com.magistr.app.model.AcademicCalendar;
import com.magistr.app.model.AcademicCalendarActivityType;
import com.magistr.app.model.AcademicCalendarPeriod;
import com.magistr.app.model.AcademicYear;
import com.magistr.app.model.EducationForm;
import com.magistr.app.model.Speciality;
import com.magistr.app.model.SpecialtyProfile;
import com.magistr.app.repository.AcademicCalendarPeriodRepository;
import com.magistr.app.repository.AcademicCalendarRepository;
import com.magistr.app.repository.AcademicCalendarSubjectRepository;
import com.magistr.app.repository.AcademicYearRepository;
import com.magistr.app.repository.EducationFormRepository;
import com.magistr.app.repository.SpecialtiesRepository;
import com.magistr.app.repository.SpecialtyProfileRepository;
import com.magistr.app.repository.SubjectRepository;
import com.magistr.app.service.AcademicCalendarGridService;
import com.magistr.app.service.AcademicStructureService;
import com.magistr.app.service.ScheduleGeneratorService;
import org.junit.jupiter.api.Test;

import java.time.LocalDate;
import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

class AcademicCalendarControllerTest {

    @Test
    void createCalendarBuildsTitleWithoutClientValue() {
        AcademicCalendarRepository calendarRepository = mock(AcademicCalendarRepository.class);
        AcademicYearRepository academicYearRepository = mock(AcademicYearRepository.class);
        SpecialtiesRepository specialtiesRepository = mock(SpecialtiesRepository.class);
        SpecialtyProfileRepository profileRepository = mock(SpecialtyProfileRepository.class);
        EducationFormRepository educationFormRepository = mock(EducationFormRepository.class);

        AcademicYear year = new AcademicYear();
        year.setId(1L);
        year.setTitle("2026-2027");
        year.setStartDate(LocalDate.of(2026, 9, 1));
        year.setEndDate(LocalDate.of(2027, 6, 30));
        Speciality speciality = new Speciality(2L, "Программная инженерия", "09.03.04");
        SpecialtyProfile profile = new SpecialtyProfile();
        profile.setId(3L);
        profile.setSpeciality(speciality);
        profile.setName("Разработка ПО");
        EducationForm studyForm = new EducationForm();
        studyForm.setId(4L);
        studyForm.setName("Очная");

        when(academicYearRepository.findById(1L)).thenReturn(Optional.of(year));
        when(specialtiesRepository.findById(2L)).thenReturn(Optional.of(speciality));
        when(profileRepository.findById(3L)).thenReturn(Optional.of(profile));
        when(educationFormRepository.findById(4L)).thenReturn(Optional.of(studyForm));
        when(calendarRepository.save(any(AcademicCalendar.class)))
                .thenAnswer(invocation -> invocation.getArgument(0));

        AcademicCalendarController controller = new AcademicCalendarController(
                calendarRepository,
                mock(AcademicCalendarPeriodRepository.class),
                academicYearRepository,
                specialtiesRepository,
                profileRepository,
                educationFormRepository,
                mock(SubjectRepository.class),
                mock(AcademicCalendarSubjectRepository.class),
                mock(AcademicCalendarGridService.class),
                mock(ScheduleGeneratorService.class),
                mock(AcademicStructureService.class)
        );
        AcademicCalendarDto request = new AcademicCalendarDto(
                null,
                null,
                1L,
                null,
                null,
                null,
                2L,
                null,
                null,
                3L,
                null,
                4L,
                null,
                4
        );

        var response = controller.createCalendar(request);

        assertThat(response.getStatusCode().value()).isEqualTo(200);
        assertThat(response.getBody()).isInstanceOf(AcademicCalendarDto.class);
        assertThat(((AcademicCalendarDto) response.getBody()).title())
                .isEqualTo("09.03.04 — Разработка ПО — Очная — 2026-2027");
    }

    @Test
    void getGridExpandsPeriodIntoDailyRows() {
        AcademicCalendarRepository calendarRepository = mock(AcademicCalendarRepository.class);
        AcademicCalendarPeriodRepository periodRepository = mock(AcademicCalendarPeriodRepository.class);

        AcademicYear year = new AcademicYear();
        year.setId(1L);
        year.setStartDate(LocalDate.of(2026, 9, 1));
        year.setEndDate(LocalDate.of(2027, 6, 30));

        AcademicCalendar calendar = new AcademicCalendar();
        calendar.setId(10L);
        calendar.setAcademicYear(year);

        AcademicCalendarActivityType activityType = new AcademicCalendarActivityType();
        activityType.setId(20L);
        activityType.setCode("Т");
        activityType.setName("Теоретическое обучение");
        activityType.setAllowSchedule(true);

        AcademicCalendarPeriod period = new AcademicCalendarPeriod();
        period.setId(30L);
        period.setAcademicCalendar(calendar);
        period.setCourseNumber(1);
        period.setStartDate(LocalDate.of(2026, 9, 6));
        period.setEndDate(LocalDate.of(2026, 9, 8));
        period.setActivityType(activityType);

        when(calendarRepository.existsById(10L)).thenReturn(true);
        when(periodRepository.findByCalendarIdWithActivity(10L)).thenReturn(List.of(period));

        AcademicCalendarController controller = new AcademicCalendarController(
                calendarRepository,
                periodRepository,
                mock(AcademicYearRepository.class),
                mock(SpecialtiesRepository.class),
                mock(SpecialtyProfileRepository.class),
                mock(EducationFormRepository.class),
                mock(SubjectRepository.class),
                mock(AcademicCalendarSubjectRepository.class),
                mock(AcademicCalendarGridService.class),
                mock(ScheduleGeneratorService.class),
                mock(AcademicStructureService.class)
        );

        var response = controller.getGrid(10L);

        assertThat(response.getStatusCode().value()).isEqualTo(200);
        assertThat(response.getBody()).isInstanceOf(List.class);
        @SuppressWarnings("unchecked")
        List<AcademicCalendarGridDayDto> rows = (List<AcademicCalendarGridDayDto>) response.getBody();
        assertThat(rows)
                .extracting(AcademicCalendarGridDayDto::date)
                .containsExactly(
                        LocalDate.of(2026, 9, 6),
                        LocalDate.of(2026, 9, 7),
                        LocalDate.of(2026, 9, 8)
                );
        assertThat(rows)
                .extracting(AcademicCalendarGridDayDto::weekNumber)
                .containsExactly(1, 2, 2);
        assertThat(rows)
                .extracting(AcademicCalendarGridDayDto::dayOfWeek)
                .containsExactly(7, 1, 2);
        assertThat(rows)
                .allSatisfy(row -> {
                    assertThat(row.id()).isEqualTo(30L);
                    assertThat(row.activityTypeId()).isEqualTo(20L);
                });
    }
}