Skip to content
This repository was archived by the owner on Apr 5, 2024. It is now read-only.

Commit ec86363

Browse files
open-schnickopen-schnick
committed
Added UnitTests (2/2) - Cleanup, fixes
1 parent ac2657f commit ec86363

File tree

7 files changed

+232
-69
lines changed

7 files changed

+232
-69
lines changed

‎src/main/java/de/filefighter/rest/configuration/PrepareDataBase.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ public class PrepareDataBase {
2525
private static final Logger LOG = LoggerFactory.getLogger(PrepareDataBase.class);
2626

2727
@Bean
28-
@Profile("dev,prod")
28+
@Profile({"dev", "prod"})
2929
CommandLineRunner veryImportantFileFighterStartScript() {
3030
return args -> {
3131
System.out.println();
@@ -37,11 +37,11 @@ CommandLineRunner veryImportantFileFighterStartScript() {
3737
System.out.println(" | _| | | | | | __/ | _| | | | (_| | | | | | | |_ | __/ | | ");
3838
System.out.println(" |_| |_| |_| \\___| |_| |_| \\__, | |_| |_| \\__| \\___| |_| ");
3939
System.out.println(" |___/ ");
40-
System.out.println(" Version 0.2 Last updated at 03.11.20 ");
41-
System.out.println(" Developed by Gimleux, Valentin, Open-Schnick. ");
42-
System.out.println(" Development Blog: https://filefighter.github.io ");
40+
System.out.println(" Version 0.2 Last updated at 03.11.20 ");
41+
System.out.println(" Developed by Gimleux, Valentin, Open-Schnick. ");
42+
System.out.println(" Development Blog: https://filefighter.github.io ");
4343
System.out.println(" The code can be found at: https://www.github.com/filefighter ");
44-
System.out.println(" Running on http://localhost:"+serverPort);
44+
System.out.println(" Running on http://localhost:" + serverPort);
4545
System.out.println();
4646
System.out.println("-------------------------------< REST API >-------------------------------");
4747
System.out.println();

‎src/main/java/de/filefighter/rest/domain/user/business/UserBusinessService.java‎

Lines changed: 18 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@
77
import de.filefighter.rest.domain.user.data.persistance.UserRepository;
88
import de.filefighter.rest.domain.user.exceptions.UserNotAuthenticatedException;
99
import de.filefighter.rest.domain.user.exceptions.UserNotFoundException;
10+
import org.slf4j.Logger;
11+
import org.slf4j.LoggerFactory;
1012
import org.springframework.stereotype.Service;
1113

1214
import java.io.UnsupportedEncodingException;
@@ -24,6 +26,8 @@ public class UserBusinessService {
2426
private final UserRepository userRepository;
2527
private final UserDtoService userDtoService;
2628

29+
private static final Logger LOG = LoggerFactory.getLogger(UserBusinessService.class);
30+
2731
public UserBusinessService(UserRepository userRepository, UserDtoService userDtoService) {
2832
this.userRepository = userRepository;
2933
this.userDtoService = userDtoService;
@@ -33,22 +37,23 @@ public long getUserCount() {
3337
return userRepository.count();
3438
}
3539

36-
public User getUserByUsernameAndPassword(String base64encodedUserAndPassword) {
37-
if (!stringIsValid(base64encodedUserAndPassword))
40+
public User getUserByUsernameAndPassword(String base64encodedUserAndPasswordWithHeaderPrefix) {
41+
if (!stringIsValid(base64encodedUserAndPasswordWithHeaderPrefix))
3842
throw new UserNotAuthenticatedException("Header was empty.");
3943

4044
//TODO: maybe filter unsupported characters?
41-
if (!base64encodedUserAndPassword.matches("^"+AUTHORIZATION_BASIC_PREFIX+"(.*)$"))
42-
throw new UserNotAuthenticatedException("Header does not contain '"+AUTHORIZATION_BASIC_PREFIX+"', or format is invalid.");
45+
if (!base64encodedUserAndPasswordWithHeaderPrefix.matches("^" + AUTHORIZATION_BASIC_PREFIX + "[^\\s](.*)$"))
46+
throw new UserNotAuthenticatedException("Header does not contain '" + AUTHORIZATION_BASIC_PREFIX + "', or format is invalid.");
4347

44-
String[] split = base64encodedUserAndPassword.split(AUTHORIZATION_BASIC_PREFIX);
48+
String[] split = base64encodedUserAndPasswordWithHeaderPrefix.split(AUTHORIZATION_BASIC_PREFIX);
4549

46-
base64encodedUserAndPassword = split[1];
50+
base64encodedUserAndPasswordWithHeaderPrefix = split[1];
4751
String decodedUsernameUndPassword;
4852
try {
49-
byte[] decodedValue = Base64.getDecoder().decode(base64encodedUserAndPassword);
53+
byte[] decodedValue = Base64.getDecoder().decode(base64encodedUserAndPasswordWithHeaderPrefix);
5054
decodedUsernameUndPassword = new String(decodedValue, StandardCharsets.UTF_8.toString());
51-
} catch (UnsupportedEncodingException ex) {
55+
} catch (UnsupportedEncodingException | IllegalArgumentException ex) {
56+
LOG.warn("Found UnsupportedEncodingException in {}", base64encodedUserAndPasswordWithHeaderPrefix);
5257
throw new RuntimeException(ex);
5358
}
5459

@@ -62,7 +67,7 @@ public User getUserByUsernameAndPassword(String base64encodedUserAndPassword) {
6267

6368
UserEntity userEntity = userRepository.findByUsernameAndPassword(username, password);
6469
if (null == userEntity)
65-
throw new UserNotAuthenticatedException("No User found for username or password.");
70+
throw new UserNotFoundException("No User found with this username and password.");
6671

6772
return userDtoService.createDto(userEntity);
6873
}
@@ -74,7 +79,7 @@ public RefreshToken getRefreshTokenForUser(User user) {
7479

7580
String refreshTokenValue = userEntity.getRefreshToken();
7681

77-
if(!stringIsValid(refreshTokenValue))
82+
if (!stringIsValid(refreshTokenValue))
7883
throw new IllegalStateException("RefreshToken was empty in db.");
7984

8085
return RefreshToken
@@ -90,18 +95,18 @@ public User getUserByRefreshTokenAndUserId(String refreshToken, long userId) {
9095

9196
UserEntity userEntity = userRepository.findByRefreshTokenAndUserId(refreshToken, userId);
9297
if (null == userEntity)
93-
throw new UserNotAuthenticatedException(userId);
98+
throw new UserNotFoundException(userId);
9499

95100
return userDtoService.createDto(userEntity);
96101
}
97102

98103
public User getUserByAccessTokenAndUserId(AccessToken accessToken, long userId) {
99-
if(accessToken.getUserId() != userId)
104+
if (accessToken.getUserId() != userId)
100105
throw new UserNotAuthenticatedException(userId);
101106

102107
UserEntity userEntity = userRepository.findByUserId(userId);
103108
if (null == userEntity)
104-
throw new UserNotFoundException();
109+
throw new UserNotFoundException(userId);
105110

106111
return userDtoService.createDto(userEntity);
107112
}

‎src/test/java/de/filefighter/rest/domain/user/business/UserBusinessServiceUnitTest.java‎

Lines changed: 157 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,16 @@
11
package de.filefighter.rest.domain.user.business;
22

3+
import de.filefighter.rest.domain.token.data.dto.AccessToken;
4+
import de.filefighter.rest.domain.token.data.dto.RefreshToken;
5+
import de.filefighter.rest.domain.user.data.dto.User;
6+
import de.filefighter.rest.domain.user.data.persistance.UserEntity;
37
import de.filefighter.rest.domain.user.data.persistance.UserRepository;
8+
import de.filefighter.rest.domain.user.exceptions.UserNotAuthenticatedException;
9+
import de.filefighter.rest.domain.user.exceptions.UserNotFoundException;
410
import org.junit.jupiter.api.BeforeEach;
511
import org.junit.jupiter.api.Test;
612

13+
import static de.filefighter.rest.configuration.RestConfiguration.AUTHORIZATION_BASIC_PREFIX;
714
import static org.junit.jupiter.api.Assertions.*;
815
import static org.mockito.Mockito.mock;
916
import static org.mockito.Mockito.when;
@@ -21,32 +28,173 @@ void setUp() {
2128

2229
@Test
2330
void getUserCount() {
24-
long expectedCount = 420;
31+
long count = 20;
2532

26-
when(userRepositoryMock.count()).thenReturn(expectedCount);
33+
when(userRepositoryMock.count()).thenReturn(count);
2734

28-
long actualCount = userBusinessService.getUserCount();
35+
long actual = userBusinessService.getUserCount();
2936

30-
assertEquals(expectedCount, actualCount);
37+
assertEquals(count, actual);
3138
}
3239

3340
@Test
34-
void getUserByUsernameAndPassword() {
41+
void getUserByUsernameAndPasswordThrowsErrors() {
42+
String notValid = "";
43+
String validButDoesntMatch = "something";
44+
String matchesButIsNotSupportedEncoding = AUTHORIZATION_BASIC_PREFIX + "���";
45+
String withoutFormalRequirements = AUTHORIZATION_BASIC_PREFIX + "dWdhYnVnYXBhc3N3b3Jk"; //ugabugapassword
46+
String userNotFound = AUTHORIZATION_BASIC_PREFIX + "dXNlcjpwYXNzd29yZA=="; // user:password
47+
48+
assertThrows(UserNotAuthenticatedException.class, () ->
49+
userBusinessService.getUserByUsernameAndPassword(notValid)
50+
);
51+
assertThrows(UserNotAuthenticatedException.class, () ->
52+
userBusinessService.getUserByUsernameAndPassword(validButDoesntMatch)
53+
);
54+
assertThrows(RuntimeException.class, () ->
55+
userBusinessService.getUserByUsernameAndPassword(matchesButIsNotSupportedEncoding)
56+
);
57+
assertThrows(UserNotAuthenticatedException.class, () ->
58+
userBusinessService.getUserByUsernameAndPassword(withoutFormalRequirements)
59+
);
60+
61+
when(userRepositoryMock.findByUsernameAndPassword("user", "password")).thenReturn(null);
62+
assertThrows(UserNotFoundException.class, () ->
63+
userBusinessService.getUserByUsernameAndPassword(userNotFound)
64+
);
65+
}
66+
67+
@Test
68+
void getUserByUsernameAndPasswordWorksCorrectly() {
69+
String header = AUTHORIZATION_BASIC_PREFIX + "dXNlcjpwYXNzd29yZA=="; // user:password
70+
User dummyUser = User.builder().build();
71+
UserEntity dummyEntity = UserEntity.builder().build();
72+
73+
when(userRepositoryMock.findByUsernameAndPassword("user", "password")).thenReturn(dummyEntity);
74+
when(userDtoServiceMock.createDto(dummyEntity)).thenReturn(dummyUser);
75+
76+
User actual = userBusinessService.getUserByUsernameAndPassword(header);
77+
assertEquals(dummyUser, actual);
78+
}
79+
80+
@Test
81+
void getRefreshTokenForUserWithoutUser() {
82+
String invalidString = "";
83+
long userId = 420;
84+
String username = "someString";
85+
86+
User dummyUser = User.builder().id(userId).username(username).build();
87+
88+
when(userRepositoryMock.findByUserIdAndUsername(userId, username)).thenReturn(null);
89+
90+
assertThrows(UserNotFoundException.class, () ->
91+
userBusinessService.getRefreshTokenForUser(dummyUser)
92+
);
3593
}
3694

3795
@Test
38-
void getRefreshTokenForUser() {
96+
void getRefreshTokenForUserWithInvalidString() {
97+
String invalidString = "";
98+
long userId = 420;
99+
String username = "someString";
100+
101+
User dummyUser = User.builder().id(userId).username(username).build();
102+
UserEntity dummyEntity = UserEntity.builder().refreshToken(invalidString).build();
103+
104+
when(userRepositoryMock.findByUserIdAndUsername(userId, username)).thenReturn(dummyEntity);
105+
106+
assertThrows(IllegalStateException.class, () ->
107+
userBusinessService.getRefreshTokenForUser(dummyUser)
108+
);
39109
}
40110

41111
@Test
42-
void getUserByRefreshTokenAndUserId() {
112+
void getCorrectRefreshTokenForUser() {
113+
long userId = 420;
114+
String username = "someString";
115+
String refreshToken = "someToken";
116+
User dummyUser = User.builder().id(userId).username(username).build();
117+
UserEntity dummyEntity = UserEntity.builder().refreshToken(refreshToken).build();
118+
RefreshToken expected = RefreshToken.builder().refreshToken(refreshToken).user(dummyUser).build();
119+
120+
when(userRepositoryMock.findByUserIdAndUsername(userId, username)).thenReturn(dummyEntity);
121+
122+
RefreshToken actual = userBusinessService.getRefreshTokenForUser(dummyUser);
123+
assertEquals(expected, actual);
43124
}
44125

126+
// -------------------------------------------------------------------------------------------- //
127+
45128
@Test
46-
void getUserByAccessTokenAndUserId() {
129+
void getUserByAccessTokenAndUserIdWithInvalidUserId() {
130+
long userId = 420;
131+
AccessToken dummyAccessToken = AccessToken.builder().userId(300).build();
132+
133+
assertThrows(UserNotAuthenticatedException.class, () ->
134+
userBusinessService.getUserByAccessTokenAndUserId(dummyAccessToken, userId)
135+
);
47136
}
48137

49138
@Test
50-
void getUserEntityByUserIdAndUsername() {
139+
void getUserByAccessTokenAndUserIdWithoutUser() {
140+
long userId = 420;
141+
AccessToken accessToken = AccessToken.builder().userId(userId).build();
142+
143+
when(userRepositoryMock.findByUserId(userId)).thenReturn(null);
144+
145+
assertThrows(UserNotFoundException.class, () ->
146+
userBusinessService.getUserByAccessTokenAndUserId(accessToken, userId)
147+
);
148+
}
149+
150+
@Test
151+
void getUserByAccessTokenAndUserIdCorrectly() {
152+
long userId = 420;
153+
AccessToken accessToken = AccessToken.builder().userId(userId).build();
154+
User dummyUser = User.builder().id(userId).build();
155+
UserEntity dummyEntity = UserEntity.builder().build();
156+
157+
when(userRepositoryMock.findByUserId(userId)).thenReturn(dummyEntity);
158+
when(userDtoServiceMock.createDto(dummyEntity)).thenReturn(dummyUser);
159+
160+
User actual = userBusinessService.getUserByAccessTokenAndUserId(accessToken, userId);
161+
162+
assertEquals(dummyUser, actual);
163+
}
164+
165+
// -------------------------------------------------------------------------------------------- //
166+
167+
@Test
168+
void getUserByRefreshTokenAndUserIdWithInvalidToken() {
169+
assertThrows(UserNotAuthenticatedException.class, () ->
170+
userBusinessService.getUserByRefreshTokenAndUserId("", 0)
171+
);
172+
}
173+
174+
@Test
175+
void getUserByRefreshTokenAndUserIdWithoutUser() {
176+
String token = "token";
177+
long userId = 420;
178+
179+
when(userRepositoryMock.findByRefreshTokenAndUserId(token, userId)).thenReturn(null);
180+
181+
assertThrows(UserNotFoundException.class, () ->
182+
userBusinessService.getUserByRefreshTokenAndUserId(token, userId)
183+
);
184+
}
185+
186+
@Test
187+
void getUserByRefreshTokenAndUserIdCorrectly() {
188+
String token = "token";
189+
long userId = 420;
190+
User dummyUser = User.builder().id(userId).build();
191+
UserEntity dummyEntity = UserEntity.builder().refreshToken(token).build();
192+
193+
when(userRepositoryMock.findByRefreshTokenAndUserId(token, userId)).thenReturn(dummyEntity);
194+
when(userDtoServiceMock.createDto(dummyEntity)).thenReturn(dummyUser);
195+
196+
User actual = userBusinessService.getUserByRefreshTokenAndUserId(token, userId);
197+
198+
assertEquals(dummyUser, actual);
51199
}
52200
}

‎src/test/java/de/filefighter/rest/domain/user/business/UserDtoServiceUnitTest.java‎

Lines changed: 47 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,67 @@
11
package de.filefighter.rest.domain.user.business;
22

3+
import de.filefighter.rest.domain.user.data.dto.User;
4+
import de.filefighter.rest.domain.user.data.persistance.UserEntity;
5+
import de.filefighter.rest.domain.user.data.persistance.UserRepository;
6+
import de.filefighter.rest.domain.user.exceptions.UserNotFoundException;
7+
import de.filefighter.rest.domain.user.role.GroupRepository;
8+
import de.filefighter.rest.domain.user.role.Groups;
39
import org.junit.jupiter.api.BeforeEach;
410
import org.junit.jupiter.api.Test;
511

612
import static org.junit.jupiter.api.Assertions.*;
13+
import static org.mockito.Mockito.mock;
14+
import static org.mockito.Mockito.when;
715

816
class UserDtoServiceUnitTest {
917

18+
private final GroupRepository groupRepositoryMock = mock(GroupRepository.class);
19+
private final UserRepository userRepositoryMock = mock(UserRepository.class);
20+
private UserDtoService userDtoService;
21+
1022
@BeforeEach
1123
void setUp() {
24+
userDtoService = new UserDtoService(groupRepositoryMock, userRepositoryMock);
1225
}
1326

1427
@Test
1528
void createDto() {
29+
long userId = 0;
30+
String username = "kevin";
31+
long[] groups = new long[]{0};
32+
UserEntity dummyEntity = UserEntity.builder().userId(userId).groupIds(groups).username(username).build();
33+
34+
when(groupRepositoryMock.getRolesByIds(groups)).thenReturn(new Groups[]{Groups.FAMILY});
35+
36+
User actualUser = userDtoService.createDto(dummyEntity);
37+
assertEquals(userId, actualUser.getId());
38+
assertEquals(username, actualUser.getUsername());
39+
assertEquals(groups[0], actualUser.getGroups()[0].getGroupId());
40+
}
41+
42+
@Test
43+
void findEntityThrowsException() {
44+
long userId = 0;
45+
String username = "kevin";
46+
User user = User.builder().username(username).id(userId).build();
47+
48+
when(userRepositoryMock.findByUserIdAndUsername(userId, username)).thenReturn(null);
49+
50+
assertThrows(UserNotFoundException.class, () ->
51+
userDtoService.findEntity(user)
52+
);
1653
}
1754

1855
@Test
19-
void findEntity() {
56+
void findEntityWorksCorrectly() {
57+
long userId = 0;
58+
String username = "kevin";
59+
User user = User.builder().username(username).id(userId).build();
60+
UserEntity expected = UserEntity.builder().username(username).userId(userId).build();
61+
62+
when(userRepositoryMock.findByUserIdAndUsername(userId, username)).thenReturn(expected);
63+
UserEntity actual = userDtoService.findEntity(user);
64+
65+
assertEquals(expected, actual);
2066
}
2167
}

0 commit comments

Comments
 (0)