unit tests for services added

src/test/java/ru/ylab/service/AuditionEventServiceTest.java

@@ -0,0 +1,62 @@
+package ru.ylab.service;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import ru.ylab.entity.AuditionEvent;
+import ru.ylab.entity.User;
+import ru.ylab.enumerated.AuditionEventType;
+import ru.ylab.in.dto.AuditionEventDTO;
+import ru.ylab.mapper.AuditionEventMapper;
+import ru.ylab.repository.AuditionEventRepository;
+
+import java.util.Collection;
+import java.util.Set;
+
+class AuditionEventServiceTest {
+
+    @Mock
+    private AuditionEventRepository auditionEventRepository;
+
+    @InjectMocks
+    private AuditionEventService auditionEventService;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testGetEventsByUserId_whenExistingUser_thenReturnCollectionOfAuditionEventDTOs() {
+        long userId = 1L;
+        User user = User.builder().build();
+        Set<AuditionEvent> auditionEvents = Set.of(
+                AuditionEvent.builder().id(1L).user(user).type(AuditionEventType.SESSION_START).message("User logged in").build(),
+                AuditionEvent.builder().id(2L).user(user).type(AuditionEventType.SESSION_END).message("User logged out").build()
+        );
+        Mockito.when(auditionEventRepository.getEventsByUserId(userId)).thenReturn(auditionEvents);
+
+        Collection<AuditionEventDTO> result = auditionEventService.getEventsByUserId(userId);
+
+        Collection<AuditionEventDTO> expected = AuditionEventMapper.MAPPER.toAuditionEventDTOs(auditionEvents);
+        Assertions.assertEquals(expected, result);
+    }
+
+    @Test
+    void testAddEvent_whenValid_thenDoNothing() {
+        AuditionEvent auditionEvent = AuditionEvent.builder()
+                .id(1L)
+                .user(User.builder().build())
+                .type(AuditionEventType.REGISTRATION)
+                .message("User logged in")
+                .build();
+
+        auditionEventService.addEvent(auditionEvent);
+
+        Mockito.verify(auditionEventRepository, Mockito.times(1)).addEvent(auditionEvent);
+    }
+}

src/test/java/ru/ylab/service/MeterReadingsServiceTest.java

@@ -0,0 +1,92 @@
+package ru.ylab.service;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import ru.ylab.entity.Meter;
+import ru.ylab.entity.MeterReading;
+import ru.ylab.entity.Submission;
+import ru.ylab.entity.User;
+import ru.ylab.in.dto.MeterReadingDTO;
+import ru.ylab.mapper.MeterReadingMapper;
+import ru.ylab.repository.MeterReadingsRepository;
+
+import java.util.Collection;
+import java.util.Set;
+
+class MeterReadingsServiceTest {
+
+    @Mock
+    private MeterReadingsRepository meterReadingsRepository;
+
+    @InjectMocks
+    private MeterReadingsService meterReadingsService;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testGetByUser_whenExistingUser_thenReturnCollectionOfMeterReadings() {
+        long userId = 1L;
+        User user = User.builder().id(userId).name("testUser").password("password").build();
+        Submission submission = Submission.builder().user(user).build();
+        Set<MeterReading> meterReadings = Set.of(
+                MeterReading.builder().id(1L).submission(submission).value(100L).build(),
+                MeterReading.builder().id(2L).submission(submission).value(150L).build()
+        );
+        Mockito.when(meterReadingsRepository.getByUserId(userId)).thenReturn(meterReadings);
+
+        Collection<MeterReading> result = meterReadingsService.getByUser(user);
+
+        Assertions.assertEquals(meterReadings, result);
+    }
+
+    @Test
+    void testGetAllBySubmissionId_whenExistingSubmissionId_thenReturnSetOfMeterReadingDTOs() {
+        long submissionId = 1L;
+        Submission submission = Submission.builder().build();
+        Set<MeterReading> meterReadings = Set.of(
+                MeterReading.builder().id(1L).submission(submission).value(100L).build(),
+                MeterReading.builder().id(2L).submission(submission).value(150L).build()
+        );
+        Mockito.when(meterReadingsRepository.getAllBySubmissionId(submissionId)).thenReturn(meterReadings);
+
+        Set<MeterReadingDTO> result = meterReadingsService.getAllBySubmissionId(submissionId);
+
+        Set<MeterReadingDTO> expected = MeterReadingMapper.MAPPER.toMeterReadingDTOSet(meterReadings);
+        Assertions.assertEquals(expected, result);
+    }
+
+    @Test
+    void testSaveMeterReading_whenValid_thenDoNothing() {
+        MeterReading meterReading = MeterReading.builder()
+                .id(1L)
+                .submission(Submission.builder().build())
+                .meter(Meter.builder().build())
+                .value(100L)
+                .build();
+
+        meterReadingsService.save(meterReading);
+
+        Mockito.verify(meterReadingsRepository, Mockito.times(1)).save(meterReading);
+    }
+
+    @Test
+    void testSaveAllMeterReadings_whenValid_thenDoNothing() {
+        Submission submission = Submission.builder().build();
+        Set<MeterReading> meterReadings = Set.of(
+                MeterReading.builder().id(1L).submission(submission).value(100L).build(),
+                MeterReading.builder().id(2L).submission(submission).value(150L).build()
+        );
+
+        meterReadingsService.saveAll(meterReadings);
+
+        Mockito.verify(meterReadingsRepository, Mockito.times(1)).saveAll(meterReadings);
+    }
+}

src/test/java/ru/ylab/service/MeterServiceTest.java

@@ -0,0 +1,103 @@
+package ru.ylab.service;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import ru.ylab.entity.Meter;
+import ru.ylab.entity.MeterType;
+import ru.ylab.in.dto.MeterDTO;
+import ru.ylab.mapper.MeterMapper;
+import ru.ylab.repository.MeterRepository;
+import ru.ylab.repository.MeterTypeRepository;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
+
+class MeterServiceTest {
+
+    @Mock
+    private MeterRepository meterRepository;
+
+    @Mock
+    private MeterTypeRepository meterTypeRepository;
+
+    @InjectMocks
+    private MeterService meterService;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testSaveMeter_whenCorrect_thenDoNothing() {
+        MeterType typeElectricity = MeterType.builder().typeName("Electricity").build();
+        Meter meter = Meter.builder().factoryNumber("123456789012").type(typeElectricity).build();
+
+        meterService.save(meter);
+
+        Mockito.verify(meterRepository, Mockito.times(1)).save(meter);
+    }
+
+    @Test
+    void testSaveMeter_whenCorrectInCollection_thenDoNothing() {
+        MeterType typeElectricity = MeterType.builder().typeName("Electricity").build();
+        MeterType typeGas = MeterType.builder().typeName("Gas").build();
+        Meter meter1 = Meter.builder().factoryNumber("123456789012").type(typeElectricity).build();
+        Meter meter2 = Meter.builder().factoryNumber("987654321098").type(typeGas).build();
+        Collection<Meter> meters = Arrays.asList(meter1, meter2);
+
+        meterService.save(meters);
+
+        Mockito.verify(meterRepository, Mockito.times(1)).save(meters);
+    }
+
+    @Test
+    void testGetMeterById_whenCorrect_thenReturnMeter() {
+        long meterId = 1L;
+        MeterType typeElectricity = MeterType.builder().typeName("Electricity").build();
+        Meter meter = Meter.builder().id(meterId).factoryNumber("123456789012").type(typeElectricity).build();
+        Mockito.when(meterRepository.findById(meterId)).thenReturn(Optional.of(meter));
+
+        Meter result = meterService.getById(meterId);
+
+        Assertions.assertEquals(meter, result);
+    }
+
+    @Test
+    void testGetMeterDTOsByUserId_whenCorrect_thenReturnCollectionOfMeterDTOs() {
+        long userId = 1L;
+        MeterType typeElectricity = MeterType.builder().typeName("Electricity").build();
+        MeterType typeGas = MeterType.builder().typeName("Gas").build();
+        Meter meter1 = Meter.builder().factoryNumber("123456789012").type(typeElectricity).build();
+        Meter meter2 = Meter.builder().factoryNumber("987654321098").type(typeGas).build();
+        Set<Meter> meters = Set.of(meter1, meter2);
+        Mockito.when(meterRepository.getByUserId(userId)).thenReturn(meters);
+
+        Collection<MeterDTO> result = meterService.getMeterDTOsByUserId(userId);
+
+        Collection<MeterDTO> expected = MeterMapper.MAPPER.toMeterDTOs(meters);
+        Assertions.assertEquals(expected, result);
+    }
+
+    @Test
+    void testGetMetersByUserId_whenCorrect_thenReturnCollectionOfMeters() {
+        long userId = 1L;
+        MeterType typeElectricity = MeterType.builder().typeName("Electricity").build();
+        MeterType typeGas = MeterType.builder().typeName("Gas").build();
+        Meter meter1 = Meter.builder().factoryNumber("123456789012").type(typeElectricity).build();
+        Meter meter2 = Meter.builder().factoryNumber("987654321098").type(typeGas).build();
+        Set<Meter> meters = Set.of(meter1, meter2);
+        Mockito.when(meterRepository.getByUserId(userId)).thenReturn(meters);
+
+        Collection<Meter> result = meterService.getMetersByUserId(userId);
+
+        Assertions.assertEquals(meters, result);
+    }
+}

src/test/java/ru/ylab/service/MeterTypeServiceTest.java

@@ -0,0 +1,109 @@
+package ru.ylab.service;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import ru.ylab.entity.MeterType;
+import ru.ylab.exception.MeterTypeExistException;
+import ru.ylab.exception.MeterTypeNotFoundException;
+import ru.ylab.in.dto.MeterTypeDTO;
+import ru.ylab.repository.MeterTypeRepository;
+
+import java.util.Collection;
+
+class MeterTypeServiceTest {
+
+    @Mock
+    private MeterTypeRepository meterTypeRepository;
+
+    @Mock
+    private AuditionEventService auditionEventService;
+
+    @Mock
+    private UserService userService;
+
+    @InjectMocks
+    private MeterTypeService meterTypeService;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testSaveMeterType_whenNonExistingType_thenDoNothing() {
+        String typeName = "Electricity";
+        Mockito.when(meterTypeRepository.checkExistsByName(typeName)).thenReturn(false);
+
+        meterTypeService.save(typeName);
+
+        Mockito.verify(meterTypeRepository, Mockito.times(1)).save(Mockito.any(MeterType.class));
+        Mockito.verify(auditionEventService, Mockito.times(1)).addEvent(Mockito.any());
+    }
+
+    @Test
+    void testSaveMeterType_whenExistingType_thenThrowMeterTypeExistException() {
+        String typeName = "Electricity";
+        Mockito.when(meterTypeRepository.checkExistsByName(typeName)).thenReturn(true);
+
+        Assertions.assertThrows(MeterTypeExistException.class, () -> meterTypeService.save(typeName));
+        Mockito.verify(meterTypeRepository, Mockito.times(0)).save(Mockito.any(MeterType.class));
+        Mockito.verify(auditionEventService, Mockito.times(0)).addEvent(Mockito.any());
+    }
+
+    @Test
+    void testGetById_whenExistingType_thenReturnMeterTypeDTO() {
+        long meterTypeId = 1L;
+        MeterType meterType = MeterType.builder().id(meterTypeId).typeName("Electricity").build();
+        Mockito.when(meterTypeRepository.findById(meterTypeId)).thenReturn(java.util.Optional.of(meterType));
+
+        MeterTypeDTO result = meterTypeService.getById(meterTypeId);
+
+        Assertions.assertNotNull(result);
+        Assertions.assertEquals(meterType.getTypeName(), result.typeName());
+    }
+
+    @Test
+    void testGetById_whenNonExistingType_thenThrowMeterTypeNotFoundException() {
+        long meterTypeId = 1L;
+        Mockito.when(meterTypeRepository.findById(meterTypeId)).thenReturn(java.util.Optional.empty());
+
+        Assertions.assertThrows(MeterTypeNotFoundException.class, () -> meterTypeService.getById(meterTypeId));
+    }
+
+    @Test
+    void testGetAll_whenTypesExist_thenReturnCollectionOfMeterTypes() {
+        MeterType type1 = MeterType.builder().typeName("Electricity").build();
+        MeterType type2 = MeterType.builder().typeName("Water").build();
+        Collection<MeterType> types = java.util.List.of(type1, type2);
+        Mockito.when(meterTypeRepository.getAll()).thenReturn(types);
+
+        Collection<MeterType> result = meterTypeService.getAll();
+
+        Assertions.assertEquals(types, result);
+    }
+
+    @Test
+    void testCheckExistsByName_whenExistingType_thenReturnTrue() {
+        String typeName = "Electricity";
+        Mockito.when(meterTypeRepository.checkExistsByName(typeName)).thenReturn(true);
+
+        boolean result = meterTypeService.checkExistsByName(typeName);
+
+        Assertions.assertTrue(result);
+    }
+
+    @Test
+    void testCheckExistsByName_whenNonExistingType_thenReturnFalse() {
+        String typeName = "Electricity";
+        Mockito.when(meterTypeRepository.checkExistsByName(typeName)).thenReturn(false);
+
+        boolean result = meterTypeService.checkExistsByName(typeName);
+
+        Assertions.assertFalse(result);
+    }
+}