Skip to content

Commit cb4c392

Browse files
aitestmate-epamaitestmate-epam
committed
[chore] [mod-data-export] unit tests
1 parent 4018353 commit cb4c392

2 files changed

Lines changed: 200 additions & 0 deletions

File tree

‎src/test/java/org/folio/dataexp/service/JobProfileServiceTest.java‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,7 @@
4141
import org.mockito.InjectMocks;
4242
import org.mockito.Mock;
4343
import org.mockito.junit.jupiter.MockitoExtension;
44+
import org.folio.dataexp.domain.dto.UserInfo;
4445

4546
@ExtendWith(MockitoExtension.class)
4647
class JobProfileServiceTest {
@@ -885,6 +886,56 @@ void shouldHandleUnlockingWhenCurrentUserHasPermission() {
885886
assertThat(savedProfile.getLockedAt()).isNull();
886887
}
887888

889+
@Test
890+
void postJobProfileShouldLockProfileWhenLockedIsTrueAndPermissionExists() {
891+
// TestMate-029c7d5c8c6c036fad395b01ed77f442
892+
// Given
893+
jobProfile.setLocked(TRUE);
894+
when(folioExecutionContext.getUserId()).thenReturn(userId);
895+
when(userClient.getUserById(userId.toString())).thenReturn(user);
896+
when(permissionsValidator.checkLockJobProfilePermission()).thenReturn(true);
897+
when(jobProfileEntityRepository.save(any(JobProfileEntity.class)))
898+
.thenAnswer(
899+
invocation -> {
900+
JobProfileEntity entity = invocation.getArgument(0);
901+
// Simulate DB saving and returning the saved entity
902+
return entity;
903+
});
904+
// When
905+
JobProfile savedProfile = jobProfileService.postJobProfile(jobProfile);
906+
// Then
907+
verify(permissionsValidator).checkLockJobProfilePermission();
908+
verify(jobProfileEntityRepository).save(jobProfileEntityCaptor.capture());
909+
JobProfile capturedProfile = jobProfileEntityCaptor.getValue().getJobProfile();
910+
assertThat(savedProfile).isSameAs(capturedProfile);
911+
assertThat(savedProfile.getLocked()).isTrue();
912+
assertThat(savedProfile.getLockedBy()).isEqualTo(userId);
913+
assertThat(savedProfile.getLockedAt()).isNotNull();
914+
Metadata metadata = savedProfile.getMetadata();
915+
assertThat(metadata.getCreatedByUserId()).isEqualTo(userId.toString());
916+
assertThat(metadata.getUpdatedByUserId()).isEqualTo(userId.toString());
917+
UserInfo userInfo = savedProfile.getUserInfo();
918+
assertThat(userInfo.getFirstName()).isEqualTo("Test");
919+
assertThat(userInfo.getLastName()).isEqualTo("User");
920+
assertThat(userInfo.getUserName()).isEqualTo("testuser");
921+
}
922+
923+
@Test
924+
void postJobProfileShouldThrowExceptionWhenLockingAndPermissionIsMissing() {
925+
// TestMate-cb876ac745b745330a34d6ebf401dcba
926+
// Given
927+
jobProfile.setLocked(TRUE);
928+
when(folioExecutionContext.getUserId()).thenReturn(userId);
929+
when(userClient.getUserById(userId.toString())).thenReturn(user);
930+
when(permissionsValidator.checkLockJobProfilePermission()).thenReturn(false);
931+
// When & Then
932+
assertThatThrownBy(() -> jobProfileService.postJobProfile(jobProfile))
933+
.isInstanceOf(LockJobProfilePermissionException.class)
934+
.hasMessage("You do not have permission to lock this profile.");
935+
verify(permissionsValidator).checkLockJobProfilePermission();
936+
verify(jobProfileEntityRepository, never()).save(any(JobProfileEntity.class));
937+
}
938+
888939
// Helper methods
889940

890941
private JobExecution createJobExecution(UUID id, String profileName, UUID profileId) {

‎src/test/java/org/folio/dataexp/service/StorageCleanUpServiceTest.java‎

Lines changed: 149 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,149 @@
1+
package org.folio.dataexp.service;
2+
3+
import org.junit.jupiter.api.extension.ExtendWith;
4+
import org.mockito.junit.jupiter.MockitoExtension;
5+
import org.folio.dataexp.domain.dto.FileDefinition;
6+
import org.folio.dataexp.domain.entity.FileDefinitionEntity;
7+
import org.folio.dataexp.repository.FileDefinitionEntityRepository;
8+
import org.folio.dataexp.util.S3FilePathUtils;
9+
import org.junit.jupiter.api.Test;
10+
import org.mockito.ArgumentCaptor;
11+
import org.mockito.Captor;
12+
import org.mockito.InjectMocks;
13+
import org.mockito.Mock;
14+
import org.mockito.MockedStatic;
15+
import org.springframework.test.util.ReflectionTestUtils;
16+
import java.util.Date;
17+
import java.util.List;
18+
import java.util.UUID;
19+
import static org.assertj.core.api.Assertions.assertThat;
20+
import static org.mockito.ArgumentMatchers.any;
21+
import static org.mockito.Mockito.mockStatic;
22+
import static org.mockito.Mockito.times;
23+
import static org.mockito.Mockito.verify;
24+
import static org.mockito.Mockito.when;
25+
import org.folio.s3.client.FolioS3Client;
26+
import java.util.Collections;
27+
import static org.mockito.Mockito.never;
28+
import org.junit.jupiter.params.ParameterizedTest;
29+
import org.junit.jupiter.params.provider.ValueSource;
30+
import static org.mockito.ArgumentMatchers.anyString;
31+
import org.junit.jupiter.params.provider.MethodSource;
32+
import java.util.stream.Stream;
33+
34+
@ExtendWith(MockitoExtension.class)
35+
class StorageCleanUpServiceTest {
36+
37+
@Mock
38+
private FileDefinitionEntityRepository fileDefinitionEntityRepository;
39+
40+
@Mock
41+
private FolioS3Client storageClient;
42+
43+
@InjectMocks
44+
private StorageCleanUpService storageCleanUpService;
45+
46+
@Captor
47+
private ArgumentCaptor<FileDefinitionEntity> fileDefinitionEntityCaptor;
48+
49+
private static Stream<String> emptyDelayProvider() {
50+
return Stream.of(null, "");
51+
}
52+
53+
@Test
54+
void cleanExpiredFilesAndFileDefinitionsShouldDeleteExpiredFilesAndDefinitions() {
55+
// TestMate-3d5279a2547feaa5ee0c3879052df208
56+
try (MockedStatic<S3FilePathUtils> s3FilePathUtilsMockedStatic = mockStatic(S3FilePathUtils.class)) {
57+
// Given
58+
ReflectionTestUtils.setField(storageCleanUpService, "cleanUpFilesDelay", "24");
59+
var fileDefinition1 = new FileDefinition()
60+
.id(UUID.fromString("a72432c0-8a56-45a4-9264-3990666345a8"))
61+
.fileName("file1.csv");
62+
var fileDefinitionEntity1 = FileDefinitionEntity.builder().fileDefinition(fileDefinition1).build();
63+
var path1 = "path/to/file1.csv";
64+
var fileDefinition2 = new FileDefinition()
65+
.id(UUID.fromString("f36551b3-4983-4f32-a5d6-0a693c10a316"))
66+
.fileName("file2.csv");
67+
var fileDefinitionEntity2 = FileDefinitionEntity.builder().fileDefinition(fileDefinition2).build();
68+
var path2 = "path/to/file2.csv";
69+
var expiredEntities = List.of(fileDefinitionEntity1, fileDefinitionEntity2);
70+
when(fileDefinitionEntityRepository.getExpiredEntities(any(Date.class))).thenReturn(expiredEntities);
71+
s3FilePathUtilsMockedStatic.when(() -> S3FilePathUtils.getPathToUploadedFiles(fileDefinition1.getId(), fileDefinition1.getFileName()))
72+
.thenReturn(path1);
73+
s3FilePathUtilsMockedStatic.when(() -> S3FilePathUtils.getPathToUploadedFiles(fileDefinition2.getId(), fileDefinition2.getFileName()))
74+
.thenReturn(path2);
75+
// When
76+
storageCleanUpService.cleanExpiredFilesAndFileDefinitions();
77+
// Then
78+
verify(storageClient, times(2)).remove(any(String.class));
79+
verify(storageClient).remove(path1);
80+
verify(storageClient).remove(path2);
81+
verify(fileDefinitionEntityRepository, times(2)).delete(fileDefinitionEntityCaptor.capture());
82+
assertThat(fileDefinitionEntityCaptor.getAllValues()).containsExactlyInAnyOrder(fileDefinitionEntity1, fileDefinitionEntity2);
83+
}
84+
}
85+
86+
@Test
87+
void cleanExpiredFilesAndFileDefinitionsShouldDoNothingWhenNoFilesExpired() {
88+
// TestMate-d683600f14b8bc58f1fe10bde54c70fb
89+
// Given
90+
ReflectionTestUtils.setField(storageCleanUpService, "cleanUpFilesDelay", "24");
91+
when(fileDefinitionEntityRepository.getExpiredEntities(any(Date.class))).thenReturn(Collections.emptyList());
92+
// When
93+
storageCleanUpService.cleanExpiredFilesAndFileDefinitions();
94+
// Then
95+
verify(storageClient, never()).remove(any(String.class));
96+
verify(fileDefinitionEntityRepository, never()).delete(any(FileDefinitionEntity.class));
97+
}
98+
99+
@ParameterizedTest
100+
@ValueSource(strings = {"invalid-value", "-10"})
101+
void cleanExpiredFilesAndFileDefinitionsShouldUseDefaultExpirationWhenDelayIsInvalid(String invalidDelay) {
102+
// TestMate-d55056655d850cc9e9572e201b440a92
103+
try (MockedStatic<S3FilePathUtils> s3FilePathUtilsMockedStatic = mockStatic(S3FilePathUtils.class)) {
104+
// Given
105+
ReflectionTestUtils.setField(storageCleanUpService, "cleanUpFilesDelay", invalidDelay);
106+
var fileDefinition = new FileDefinition()
107+
.id(UUID.fromString("a72432c0-8a56-45a4-9264-3990666345a8"))
108+
.fileName("expired_file.csv");
109+
var fileDefinitionEntity = FileDefinitionEntity.builder().fileDefinition(fileDefinition).build();
110+
var expiredEntities = List.of(fileDefinitionEntity);
111+
var expectedPath = "path/to/expired_file.csv";
112+
when(fileDefinitionEntityRepository.getExpiredEntities(any(Date.class))).thenReturn(expiredEntities);
113+
s3FilePathUtilsMockedStatic.when(() -> S3FilePathUtils.getPathToUploadedFiles(any(UUID.class), anyString()))
114+
.thenReturn(expectedPath);
115+
// When
116+
storageCleanUpService.cleanExpiredFilesAndFileDefinitions();
117+
// Then
118+
verify(storageClient).remove(expectedPath);
119+
verify(fileDefinitionEntityRepository).delete(fileDefinitionEntityCaptor.capture());
120+
assertThat(fileDefinitionEntityCaptor.getValue()).isEqualTo(fileDefinitionEntity);
121+
}
122+
}
123+
124+
@ParameterizedTest
125+
@MethodSource("emptyDelayProvider")
126+
void cleanExpiredFilesAndFileDefinitionsShouldUseDefaultExpirationWhenDelayIsEmpty(String emptyDelay) {
127+
// TestMate-02eafb490bd2a9cdd3ef22c8628deabf
128+
try (MockedStatic<S3FilePathUtils> s3FilePathUtilsMockedStatic = mockStatic(S3FilePathUtils.class)) {
129+
// Given
130+
ReflectionTestUtils.setField(storageCleanUpService, "cleanUpFilesDelay", emptyDelay);
131+
var fileDefinition = new FileDefinition()
132+
.id(UUID.fromString("a72432c0-8a56-45a4-9264-3990666345a8"))
133+
.fileName("expired-file.csv");
134+
var fileDefinitionEntity = FileDefinitionEntity.builder().fileDefinition(fileDefinition).build();
135+
var expiredEntities = List.of(fileDefinitionEntity);
136+
var expectedPath = "path/to/expired-file.csv";
137+
when(fileDefinitionEntityRepository.getExpiredEntities(any(Date.class))).thenReturn(expiredEntities);
138+
s3FilePathUtilsMockedStatic.when(() -> S3FilePathUtils.getPathToUploadedFiles(any(UUID.class), anyString()))
139+
.thenReturn(expectedPath);
140+
// When
141+
storageCleanUpService.cleanExpiredFilesAndFileDefinitions();
142+
// Then
143+
verify(storageClient).remove(expectedPath);
144+
verify(fileDefinitionEntityRepository).delete(fileDefinitionEntityCaptor.capture());
145+
assertThat(fileDefinitionEntityCaptor.getValue()).isEqualTo(fileDefinitionEntity);
146+
}
147+
}
148+
149+
}

0 commit comments

Comments
 (0)