1 package org.itracker.services;
2
3 import org.itracker.PasswordException;
4 import org.itracker.UserException;
5 import org.itracker.core.AuthenticationConstants;
6 import org.itracker.model.*;
7 import org.itracker.model.util.UserUtilities;
8 import org.itracker.persistence.dao.PermissionDAO;
9 import org.itracker.persistence.dao.ProjectDAO;
10 import org.itracker.persistence.dao.UserDAO;
11 import org.itracker.persistence.dao.UserPreferencesDAO;
12 import org.junit.Test;
13
14 import java.util.ArrayList;
15 import java.util.Date;
16 import java.util.Iterator;
17 import java.util.List;
18
19 import static org.itracker.Assert.*;
20 public class UserServiceImplIT extends AbstractServicesIntegrationTest {
21
22 private UserService userService;
23 private ProjectDAO projectDAO;
24 private UserDAO userDAO;
25 private PermissionDAO permissionDAO;
26 private UserPreferencesDAO userPreferencesDAO;
27
28 @Test
29 public void getSuperUsers() {
30
31 List<User> users = userService.getSuperUsers();
32
33 assertNotNull(users);
34 assertEquals(1, users.size());
35
36 }
37
38
39 @Test
40 public void testGetPermissionsByUserId() {
41 Integer userId = 3;
42 Integer projectId = 2;
43 List<Permission> currentPermissions;
44
45 Project project = projectDAO.findByPrimaryKey(projectId);
46
47 User user = userDAO.findByPrimaryKey(userId);
48
49 List<Permission> assertedPermissions = new ArrayList<Permission>();
50 assertedPermissions.add(new Permission(PermissionType.valueOf(1), user, project));
51 assertedPermissions.add(new Permission(PermissionType.valueOf(2), user, project));
52 assertedPermissions.add(new Permission(PermissionType.valueOf(3), user, project));
53
54 currentPermissions = userService.getPermissionsByUserId(userId);
55 assertEquals(assertedPermissions.get(0).getProject().getName(),
56 currentPermissions.get(0).getProject().getName());
57
58 assertEquals(assertedPermissions.get(1).getProject().getName(),
59 currentPermissions.get(1).getProject().getName());
60
61 assertEquals(assertedPermissions.get(2).getProject().getName(),
62 currentPermissions.get(2).getProject().getName());
63
64 assertEquals(assertedPermissions.get(0).getPermissionType(),
65 currentPermissions.get(0).getPermissionType());
66
67 assertEquals(assertedPermissions.get(1).getPermissionType(),
68 currentPermissions.get(1).getPermissionType());
69
70 assertEquals(assertedPermissions.get(2).getPermissionType(),
71 currentPermissions.get(2).getPermissionType());
72
73 assertEquals(assertedPermissions.get(0).getUser().getEmail(),
74 currentPermissions.get(0).getUser().getEmail());
75
76 assertEquals(assertedPermissions.get(1).getUser().getEmail(),
77 currentPermissions.get(1).getUser().getEmail());
78
79 assertEquals(assertedPermissions.get(2).getUser().getEmail(),
80 currentPermissions.get(2).getUser().getEmail());
81
82
83 currentPermissions = userService.getPermissionsByUserId(-1);
84 assertNotNull(currentPermissions);
85 assertTrue("empty permissions list", currentPermissions.isEmpty());
86 }
87
88 @Test
89 public void testSetUserPermissions() {
90 Integer userId = 3;
91 Integer projectId = 2;
92
93 List<Permission> newPermissions = new ArrayList<Permission>();
94
95 User user = userDAO.findByPrimaryKey(userId);
96
97 Project project = projectDAO.findByPrimaryKey(projectId);
98
99 Permission permission = new Permission(PermissionType.ISSUE_CLOSE, user, project);
100 permission.setCreateDate(new Date());
101 permission.setLastModifiedDate(new Date());
102
103 newPermissions.add(permission);
104
105 userService.setUserPermissions(userId, newPermissions);
106
107 assertEquals(newPermissions.get(0).getPermissionType(),
108 userService.getPermissionsByUserId(userId).get(
109 0).getPermissionType());
110
111 }
112
113 @Test
114 public void testSetAndUnsetUserPermissions() {
115 Integer userId = 3;
116 Integer projectId = 2;
117 List<Permission> newPermissions = new ArrayList<Permission>();
118
119 User user = userDAO.findByPrimaryKey(userId);
120
121 Project project = projectDAO.findByPrimaryKey(projectId);
122
123 Permission permission = new Permission(PermissionType.valueOf(4), user, project);
124 permission.setCreateDate(new Date());
125 permission.setLastModifiedDate(new Date());
126
127 newPermissions.add(permission);
128 userService.setUserPermissions(userId, newPermissions);
129
130 assertEquals(newPermissions.get(0).getPermissionType(),
131 userService.getPermissionsByUserId(userId).get(
132 0).getPermissionType());
133
134 newPermissions.clear();
135 userService.setUserPermissions(userId, newPermissions);
136
137 permission = new Permission(PermissionType.valueOf(7), user, project);
138
139
140
141 newPermissions.add(permission);
142
143 userService.setUserPermissions(userId, newPermissions);
144 Boolean contains7 = false;
145 Iterator<Permission> it = userService.getPermissionsByUserId(userId).iterator();
146 while (it.hasNext()) {
147 Permission permission2 = (Permission) it.next();
148 assertNotNull(permission2);
149 if (permission2.getPermissionType().getCode() == 7) {
150 contains7 = true;
151 }
152 }
153 assertTrue("userService.getPermissionsByUserId(userId).get(0),contains(7)", contains7);
154
155
156 }
157
158 @Test
159 public void testGetUsersWithProjectPermission() {
160 Integer projectId = 2;
161 Integer permissionId = 1;
162 List<User> users = userService.getUsersWithProjectPermission(projectId,
163 permissionId);
164 assertNotNull(users);
165 }
166
167 @Test
168 public void testUpdateUser() throws UserException {
169 User user = userService.getUser(2);
170
171 user.setEmail("updated_email@test.com");
172
173 User updatedUser = userService.updateUser(user);
174
175 assertNotNull(updatedUser);
176 assertEquals("updated_email@test.com", updatedUser.getEmail());
177 }
178
179 @Test
180 public void testUpdateUserPw() throws UserException {
181 User user = userService.getUser(2);
182
183 user.setPassword("new password");
184
185 User updatedUser = userService.updateUser(user);
186
187 assertNotNull(updatedUser);
188 assertEquals("new password", updatedUser.getPassword());
189 }
190
191 @Test
192 public void testGetPossibleOwners() {
193 Issue issue = new Issue();
194 Integer projectId = 2;
195 Integer userId = 2;
196 List<User> users =
197 userService.getPossibleOwners(issue, projectId, userId);
198 assertNotNull(users);
199 }
200
201 @Test
202 public void testUpdateUserPreferences() throws UserException {
203
204 UserPreferences userPreferences = userPreferencesDAO.findByUserId(2);
205 assertNotNull("userPreferences#2", userPreferences);
206
207 assertTrue("userPreferences#2.rememberLastSearch", userPreferences.getRememberLastSearch());
208
209 userPreferences.setRememberLastSearch(false);
210
211 UserPreferences updatedUserPreferences = userService.updateUserPreferences(userPreferences);
212
213 assertNotNull(updatedUserPreferences);
214 assertFalse(updatedUserPreferences.getRememberLastSearch());
215
216
217 User user = userService.getUser(2);
218 UserPreferences userPrefs = user.getPreferences();
219
220
221 Long date = System.currentTimeMillis();
222
223 user.setPreferences(userPrefs);
224 updatedUserPreferences = userService.updateUserPreferences(userPrefs);
225 assertNotNull(updatedUserPreferences);
226 assertTrue("lastModifiedDate >= now", updatedUserPreferences.getLastModifiedDate().getTime() <= System.currentTimeMillis());
227 assertTrue("lastModifiedDate <= date", updatedUserPreferences.getLastModifiedDate().getTime() >= date);
228
229 }
230
231
232 @Test
233 public void testGetUserByLogin() {
234
235 try {
236 User user = userService.getUserByLogin("admin_test1");
237
238 assertNotNull("admin_test1", user);
239
240 } catch (Exception e) {
241 logger.error("testGetUserByLogin: failed to lookup user", e);
242 fail(e.getMessage());
243 }
244 }
245
246 @Test
247 public void testGetUserPasswordByLogin() throws PasswordException {
248 String password = userService.getUserPasswordByLogin("admin_test1");
249 assertNotNull("password", password);
250 assertEquals(UserUtilities.encryptPassword("admin_test1"), password);
251 }
252
253 @Test
254 public void testGetAllUsers() {
255 List<User> users = userService.getAllUsers();
256 assertNotNull(users);
257 for (User user : users) {
258 assertNotNull(user);
259 }
260 assertEquals("total 5 users", 5, users.size());
261 }
262
263 @Test
264 public void testGetNumberUsers() {
265 assertEquals("total 5 users", 5, userService.getNumberUsers());
266 }
267
268 @Test
269 public void testGetActiveUsers() {
270 List<User> users = userService.getActiveUsers();
271 assertNotNull(users);
272 assertEquals("total 4 active users", 4, users.size());
273 for (User user : users) {
274 assertEquals("user is active", UserUtilities.STATUS_ACTIVE, user.getStatus());
275 }
276 }
277
278 @Test
279 public void testGenerateUserPassword() {
280 User user = new User();
281 String password;
282 try {
283 password = userService.generateUserPassword(user);
284 assertNotNull(password);
285 assertNotNull(user.getPassword());
286 } catch (PasswordException e) {
287 fail(e.getMessage());
288 }
289
290 }
291
292 @Test
293 public void testClearOwnedProjects() {
294 User user = new User("user", "password", "User", "User", "user@user.com", false);
295
296 List<Project> projects = new ArrayList<Project>(1);
297 projects.add(new Project("project"));
298 user.setProjects(projects);
299 userService.clearOwnedProjects(user);
300 assertNotNull(user.getProjects());
301 assertTrue("empty projects list", user.getProjects().isEmpty());
302
303 }
304
305 @Test
306 public void testUpdateAuthenticator() {
307 try {
308 User user = userService.getUser(2);
309 ArrayList<Permission> permissions = new ArrayList<Permission>(user.getPermissions().size());
310 permissions.addAll(user.getPermissions());
311 boolean updated = userService.updateAuthenticator(2, permissions);
312 assertTrue(updated);
313 } catch (Exception e) {
314 fail(e.getMessage());
315 }
316 }
317
318 @Test
319 public void testAddUserPermissions() {
320
321 assertEquals(4, userService.getPermissionsByUserId(2).size());
322 boolean added = userService.addUserPermissions(2, null);
323 assertFalse(added);
324
325 assertEquals(4, userService.getPermissionsByUserId(2).size());
326 added = userService.addUserPermissions(2, new ArrayList<Permission>());
327 assertEquals(4, userService.getPermissionsByUserId(2).size());
328 assertFalse(added);
329 added = userService.setUserPermissions(2, new ArrayList<Permission>());
330 assertTrue(added);
331 assertEquals(1, userService.getPermissionsByUserId(2).size());
332
333
334 List<Permission> permissions = new ArrayList<Permission>();
335 Permission p1 = new Permission();
336 Permission p2 = new Permission();
337 permissions.add(p1);
338 permissions.add(p2);
339
340 User user = userService.getUser(2);
341 p1.setUser(user);
342 p2.setUser(user);
343
344 Project proj1 = projectDAO.findAll().get(0);
345
346 p1.setProject(proj1);
347 p2.setProject(proj1);
348
349 p1.setPermissionType(PermissionType.valueOf(1));
350 p2.setPermissionType(PermissionType.valueOf(2));
351 assertEquals(1, userService.getPermissionsByUserId(2).size());
352
353 added = userService.addUserPermissions(2, permissions);
354 assertTrue(added);
355
356 assertEquals(3, userService.getPermissionsByUserId(2).size());
357
358
359 }
360
361 @Test
362 public void testRemoveUserPermissions() {
363
364 boolean removed = userService.removeUserPermissions(3, null);
365 assertFalse(removed);
366
367 removed = userService.removeUserPermissions(3, new ArrayList<Permission>());
368 assertFalse(removed);
369
370
371 List<Permission> permissions = userService.getPermissionsByUserId(3);
372 assertNotNull(permissions);
373 assertTrue("permission size for user#3", permissions.size() > 0);
374
375 removed = userService.removeUserPermissions(3, permissions);
376 assertTrue(removed);
377
378 permissions = userService.getPermissionsByUserId(3);
379 assertNotNull(permissions);
380 assertEquals("permission size for user#3", 0, permissions.size());
381
382 }
383
384 @Test
385 public void testGetUsersWithAnyProjectPermission() {
386
387 List<User> users = userService.getUsersWithAnyProjectPermission(2,
388 PermissionType.valueOf(new int[]{1}));
389 assertNotNull(users);
390 assertEquals("user 2,3", 2, users.size());
391 assertTrue("user 2,3", users.get(0).getId() == 2 || users.get(0).getId() == 3);
392 assertTrue("user 2,3", users.get(1).getId() == 2 || users.get(1).getId() == 3);
393
394 }
395
396 @Test
397 public void testAllowRegistration() {
398
399 try {
400 userService.allowRegistration(
401 new User(),
402 "password",
403 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
404 AuthenticationConstants.REQ_SOURCE_WEB);
405
406 } catch (Exception e) {
407 fail(e.getMessage());
408 }
409
410
411 }
412
413 @Test
414 public void testAllowProfileCreation() {
415
416 try {
417 userService.allowProfileCreation(
418 new User(),
419 "password",
420 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
421 AuthenticationConstants.REQ_SOURCE_WEB);
422
423 } catch (Exception e) {
424 fail(e.getMessage());
425 }
426
427
428 }
429
430 @Test
431 public void testAllowPasswordUpdates() {
432
433 try {
434 userService.allowPasswordUpdates(
435 new User(),
436 "password",
437 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
438 AuthenticationConstants.REQ_SOURCE_WEB);
439
440 } catch (Exception e) {
441 fail(e.getMessage());
442 }
443
444
445 }
446
447 @Test
448 public void testAllowPermissionUpdates() {
449
450 try {
451 userService.allowPermissionUpdates(
452 new User(),
453 "password",
454 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
455 AuthenticationConstants.REQ_SOURCE_WEB);
456
457 } catch (Exception e) {
458 fail(e.getMessage());
459 }
460
461
462 }
463
464 @Test
465 public void testCheckLogin() {
466
467 try {
468 userService.checkLogin(
469 "admin_test1",
470 "admin_test1",
471 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
472 AuthenticationConstants.REQ_SOURCE_API);
473
474 } catch (Exception e) {
475 fail(e.getMessage());
476 }
477
478
479 }
480
481 @Test
482 public void testAllowPreferenceUpdates() {
483
484 try {
485 userService.allowPreferenceUpdates(
486 new User(),
487 "password",
488 AuthenticationConstants.AUTH_TYPE_PASSWORD_PLAIN,
489 AuthenticationConstants.REQ_SOURCE_WEB);
490
491 } catch (Exception e) {
492 fail(e.getMessage());
493 }
494
495
496 }
497
498
499 @Test
500 public void testAllowProfileUpdates() {
501
502 User user = userService.getUser(2);
503
504 boolean allowProfileUpdates = userService.allowProfileUpdates(user, null, UserUtilities.AUTH_TYPE_UNKNOWN, UserUtilities.REQ_SOURCE_WEB);
505
506 assertTrue(allowProfileUpdates);
507
508 }
509
510
511 @Override
512 public void onSetUp() throws Exception {
513
514 super.onSetUp();
515
516 userService = (UserService) applicationContext.getBean("userService");
517 userPreferencesDAO = (UserPreferencesDAO) applicationContext.getBean("userPreferencesDAO");
518 projectDAO = (ProjectDAO) applicationContext.getBean("projectDAO");
519 userDAO = (UserDAO) applicationContext.getBean("userDAO");
520 permissionDAO = (PermissionDAO) applicationContext.getBean("permissionDAO");
521
522 }
523
524 protected String[] getDataSetFiles() {
525 return new String[]{
526 "dataset/userpreferencesbean_dataset.xml",
527 "dataset/userbean_dataset.xml",
528 "dataset/projectbean_dataset.xml",
529 "dataset/permissionbean_dataset.xml"
530 };
531 }
532
533 }