source: ComponentRegistry/trunk/ComponentRegistry/src/test/java/clarin/cmdi/componentregistry/impl/database/GroupServiceImplTest.java @ 5553

Last change on this file since 5553 was 5553, checked in by olhsha@mpi.nl, 10 years ago

fixing serialisation issues for List<String>. Adding unit tests for goup service
  • Property svn:mime-type set to text/plain
File size: 15.8 KB
Line 
1package clarin.cmdi.componentregistry.impl.database;
2
3import java.util.List;
4
5import org.junit.Before;
6import org.junit.Test;
7import org.springframework.beans.factory.annotation.Autowired;
8
9import clarin.cmdi.componentregistry.BaseUnitTest;
10import clarin.cmdi.componentregistry.ItemNotFoundException;
11import clarin.cmdi.componentregistry.UserUnauthorizedException;
12import clarin.cmdi.componentregistry.model.BaseDescription;
13import clarin.cmdi.componentregistry.model.ComponentDescription;
14import clarin.cmdi.componentregistry.model.Group;
15import clarin.cmdi.componentregistry.model.Ownership;
16import clarin.cmdi.componentregistry.model.ProfileDescription;
17import clarin.cmdi.componentregistry.model.RegistryUser;
18import clarin.cmdi.componentregistry.persistence.ComponentDao;
19import clarin.cmdi.componentregistry.persistence.jpa.GroupDao;
20import clarin.cmdi.componentregistry.persistence.jpa.OwnershipDao;
21import clarin.cmdi.componentregistry.persistence.jpa.UserDao;
22import clarin.cmdi.componentregistry.rest.DummyPrincipal;
23import static org.junit.Assert.*;
24
25public class GroupServiceImplTest extends BaseUnitTest {
26
27    @Autowired
28    GroupService groupService;
29    @Autowired
30    UserDao userDao;
31
32    @Autowired
33    GroupDao groupDao;
34   
35    @Autowired
36    OwnershipDao ownershipDao;
37
38    @Autowired
39    ComponentDao componentDescriptionDao;
40
41    RegistryUser user;
42    RegistryUser user2;
43    RegistryUser user3;
44
45    protected BaseDescription makeTestProfile(String sid, boolean isPublic, long ownerId) {
46        ProfileDescription profile = new ProfileDescription();
47        profile.setDescription("some description");
48        profile.setId(ProfileDescription.PROFILE_PREFIX+sid);
49        profile.setName("profilename");
50        profile.setCreatorName(DummyPrincipal.DUMMY_PRINCIPAL.getName());
51        Number id = componentDescriptionDao.insertDescription(profile, "someContent",
52                isPublic, ownerId);
53        return componentDescriptionDao.getById(id);
54    }
55
56    protected BaseDescription makeTestComponent(boolean isPublic,
57            long ownerId) {
58        BaseDescription componentDescription = new BaseDescription();
59        componentDescription.setDescription("some description");
60        componentDescription.setId(ComponentDescription.COMPONENT_PREFIX+"4567");
61        componentDescription.setName("componentname");
62        componentDescription.setCreatorName(DummyPrincipal.DUMMY_PRINCIPAL.getName());
63        Number id = componentDescriptionDao.insertDescription(
64                componentDescription, "someContent", isPublic, ownerId);
65        return componentDescriptionDao.getById(id);
66    }
67
68    @Before
69    public void setupThisTest() {
70        user = new RegistryUser();
71        user.setName("Test User");
72        user.setPrincipalName(DummyPrincipal.DUMMY_CREDENTIALS
73                .getPrincipalName());
74        user = userDao.saveAndFlush(user);
75        user = userDao.getByPrincipalName(user.getPrincipalName());
76
77        user2 = new RegistryUser();
78        user2.setName("Test User 2");
79        user2.setPrincipalName(DummyPrincipal.DUMMY_CREDENTIALS
80                .getPrincipalName() + "2");
81        user2 = userDao.saveAndFlush(user2);
82        user2 = userDao.getByPrincipalName(user2.getPrincipalName());
83
84        user3 = new RegistryUser();
85        user3.setName("Test User 3");
86        user3.setPrincipalName(DummyPrincipal.DUMMY_CREDENTIALS
87                .getPrincipalName() + "3");
88        user3 = userDao.saveAndFlush(user3);
89        user3 = userDao.getByPrincipalName(user3.getPrincipalName());
90    }
91
92    @Test
93    public void testCreateNewGroup_getGroupsOwnedByUser() {
94        // Expect no groups for the current user
95        List<Group> groups = groupService.getGroupsOwnedByUser(user
96                .getPrincipalName());
97        assertTrue(groups.isEmpty());
98
99        // Make a group
100        Group group1 = groupDao.findOne(groupService.createNewGroup("Group 1",
101                user.getPrincipalName()));
102        // and another one
103        Group group2 = groupDao.findOne(groupService.createNewGroup("Group 2",
104                user.getPrincipalName()));
105        groups = groupService.getGroupsOwnedByUser(user.getPrincipalName());
106        assertEquals(2, groups.size());
107
108        assertTrue(groups.contains(group1));
109        assertTrue(groups.contains(group2));
110    }
111
112    @Test(expected = ValidationException.class)
113    public void testCreateDuplicateGroup() {
114        // Make a group
115        groupService.createNewGroup("Group X", user.getPrincipalName());
116        // Make same group, again
117        groupService.createNewGroup("Group X", user.getPrincipalName());
118    }
119
120    @Test
121    public void testAccessToNonOwnedPrivateProfile() {
122        // Make a private profile that belongs to someone else
123        BaseDescription profile = makeTestProfile("4567", false, 9999);
124        // Expect that user can't access profile
125        boolean result = groupService
126                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
127                        user, profile);
128        assertFalse(result);
129    }
130
131    @Test
132    public void testAccessToNonOwnedPublicProfile() {
133        // Make a public profile that belongs to someone else
134        BaseDescription profile = makeTestProfile("4567", true, 9999);
135
136        // Expect that user can access the profile
137        boolean result = groupService
138                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
139                        user, profile);
140        assertTrue(result);
141    }
142
143    @Test
144    public void testAccessToOwnedPrivateProfile() {
145        // Make a profile that belongs to someone else
146        BaseDescription profile = makeTestProfile("4567", false, user.getId()
147                .longValue());
148        // Add an ownership to that profile to the current user
149        Ownership ownership = new Ownership();
150        ownership.setComponentId(profile.getId());
151        ownership.setUserId(user.getId().longValue());
152        groupService.addOwnership(ownership);
153
154        // Expect that user can access the profile
155        boolean result = groupService
156                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
157                        user, profile);
158        assertTrue(result);
159    }
160
161    @Test
162    public void testAccessViaGroupToPrivateProfile() throws ItemNotFoundException{
163        // Make a profile that belongs to someone else
164        BaseDescription profile = makeTestProfile("4567", false, 9999);
165
166        // Make a group that belongs to someone else
167        Group group = groupDao.findOne(groupService.createNewGroup("Group 1",
168                user2.getPrincipalName()));
169
170        groupService.makeMember(user.getPrincipalName(),
171                group.getName());
172        // Make me a member of that group
173
174        // Add an ownership to that profile to the group
175        Ownership ownership = new Ownership();
176        ownership.setComponentId(profile.getId());
177        ownership.setGroupId(group.getId());
178        groupService.addOwnership(ownership);
179
180        // Expect that user can access the profile
181        boolean result = groupService
182                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
183                        user, profile);
184        assertTrue(result);
185    }
186
187    @Test
188    public void testAccessToNonOwnedPrivateComponent() {
189        // Make a private profile that belongs to someone else
190        BaseDescription componentDescription = makeTestComponent(false,
191                9999);
192
193        // Expect that user can't access profile
194        boolean result = groupService
195                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
196                        user, componentDescription);
197        assertFalse(result);
198    }
199
200    @Test
201    public void testAccessToNonOwnedPublicComponent() {
202        // Make a public profile that belongs to someone else
203        BaseDescription componentDescription = makeTestComponent(true,
204                9999);
205
206        // Expect that user can access the profile
207        boolean result = groupService
208                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
209                        user, componentDescription);
210        assertTrue(result);
211    }
212
213    @Test
214    public void testAccessToOwnedPrivateComponent() {
215        // Make a profile that belongs to someone else
216        BaseDescription componentDescription = makeTestComponent(false,
217                9999);
218
219        // Add an ownership to that profile to the current user
220        Ownership ownership = new Ownership();
221        ownership.setComponentId(componentDescription.getId());
222        ownership.setUserId(user.getId().longValue());
223        groupService.addOwnership(ownership);
224
225        // Expect that user can access the profile
226        boolean result = groupService
227                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
228                        user, componentDescription);
229        assertTrue(result);
230    }
231
232    @Test
233    public void testAccessViaGroupToPrivateComponent() throws ItemNotFoundException{
234        // Make a profile that belongs to someone else
235        BaseDescription componentDescription = makeTestComponent(false,
236                user3.getId().longValue());
237
238        // Make a group that belongs to someone else
239        Group group = groupDao.findOne(groupService.createNewGroup("Group 1",
240                user2.getPrincipalName()));
241
242        // Make me a member of that group
243        groupService.makeMember(user.getPrincipalName(),
244                group.getName());
245
246        // Add an ownership to that component to the group
247        Ownership ownership = new Ownership();
248        ownership.setComponentId(componentDescription.getId());
249        ownership.setGroupId(group.getId());
250        groupService.addOwnership(ownership);
251
252        // Expect that user can access the profile
253        boolean result = groupService
254                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
255                        user, componentDescription);
256        assertTrue(result);
257    }
258
259    @Test
260    public void testTransferComponentOwnershipFromUserToGroup()  throws UserUnauthorizedException, ItemNotFoundException{
261
262        // Make a group
263        Group group = groupDao.findOne(groupService.createNewGroup("Group 1",
264                user.getPrincipalName()));
265
266        // Make user and user2 members of the same group
267        groupService.makeMember(user.getPrincipalName(), group.getName());
268       
269        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user.getPrincipalName()).contains(group));
270        groupService.makeMember(user2.getPrincipalName(), group.getName());
271        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user2.getPrincipalName()).contains(group));
272
273        // Make a component that belongs to user
274        BaseDescription componentDescription = makeTestComponent(false,
275                user.getId().longValue());
276
277        // Just for the fun of it: check that user can access the component
278        // while user2 can't
279        boolean result = groupService
280                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
281                        user, componentDescription);
282        assertTrue(result);
283        result = groupService
284                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
285                        user2, componentDescription);
286        assertFalse(result);
287
288        // user transfers ownership of the component to his group
289        groupService.transferItemOwnershipFromUserToGroup(
290                user.getPrincipalName(), group.getName(), componentDescription.getId());
291       
292        List<Ownership> ownerships = (List<Ownership>)ownershipDao.findAll();
293
294        // Check that user and user2 have access to the component...
295        result = groupService
296                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
297                        user, componentDescription);
298        assertTrue(result);
299        result = groupService
300                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
301                        user2, componentDescription);
302        assertTrue(result);
303
304        // ... but someone unreleated not
305        result = groupService
306                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
307                        user3, componentDescription);
308        assertFalse(result);
309    }
310
311    @Test
312    public void testtransferComponentOwnershipFromUserToGroup()  throws UserUnauthorizedException, ItemNotFoundException{
313
314        // Make a group
315        Group group = groupDao.findOne(groupService.createNewGroup("Group 1",
316                user.getPrincipalName()));
317
318        // Make user and user2 members of the same group
319        groupService.makeMember(user.getPrincipalName(), group.getName());
320       
321        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user.getPrincipalName()).contains(group));
322        groupService.makeMember(user2.getPrincipalName(), group.getName());
323        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user2.getPrincipalName()).contains(group));
324
325        // Make a profile that belongs to user
326        BaseDescription profileDescription= makeTestProfile("4567", false,
327                user.getId().longValue());
328
329        // Just for the fun of it: check that user can access the profile
330        // while user2 can't
331        boolean result = groupService
332                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
333                        user, profileDescription);
334        assertTrue(result);
335        result = groupService
336                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
337                        user2, profileDescription);
338        assertFalse(result);
339
340        // user transfers ownership of the component to his group
341        groupService.transferItemOwnershipFromUserToGroup(
342                user.getPrincipalName(), group.getName(),
343                profileDescription.getId());
344       
345        List<Ownership> ownerships = (List<Ownership>)ownershipDao.findAll();
346
347        // Check that user and user2 have access to the component...
348        result = groupService
349                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
350                        user, profileDescription);
351        assertTrue(result);
352        result = groupService
353                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
354                        user2, profileDescription);
355        assertTrue(result);
356
357        // ... but someone unreleated not
358        result = groupService
359                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
360                        user3, profileDescription);
361        assertFalse(result);
362    }
363
364    @Test
365    public void testTransferItemOwnershipFromUserToGroup()  throws UserUnauthorizedException, ItemNotFoundException{
366        //TODO: improve test by mixing in components and exclusing components/profiles
367        // Make a group
368        Group group = groupDao.findOne(groupService.createNewGroup("Group 1",
369                user.getPrincipalName()));
370
371        // Make user and user2 members of the same group
372        groupService.makeMember(user.getPrincipalName(), group.getName());
373       
374        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user.getPrincipalName()).contains(group));
375        groupService.makeMember(user2.getPrincipalName(), group.getName());
376        assertTrue(groupService.getGroupsOfWhichUserIsAMember(user2.getPrincipalName()).contains(group));
377
378        // Make a profile that belongs to user
379        BaseDescription profileDescription= makeTestProfile("4567", false,
380                user.getId().longValue());
381
382        // Just for the fun of it: check that user can access the profile
383        // while user2 can't
384        boolean result = groupService
385                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
386                        user, profileDescription);
387        assertTrue(result);
388        result = groupService
389                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
390                        user2, profileDescription);
391        assertFalse(result);
392
393        // user transfers ownership of the component to his group
394        groupService.transferItemOwnershipFromUserToGroup(
395                user.getPrincipalName(), group.getName(),
396                profileDescription.getId());
397       
398        List<Ownership> ownerships = (List<Ownership>)ownershipDao.findAll();
399
400        // Check that user and user2 have access to the component...
401        result = groupService
402                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
403                        user, profileDescription);
404        assertTrue(result);
405        result = groupService
406                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
407                        user2, profileDescription);
408        assertTrue(result);
409
410        // ... but someone unreleated not
411        result = groupService
412                .canUserAccessComponentEitherOnHisOwnOrThroughGroupMembership(
413                        user3, profileDescription);
414        assertFalse(result);
415    }
416
417    @Test
418    public void testGetGroupsTheItemIsAMemberOf()  throws UserUnauthorizedException, ItemNotFoundException{
419        // Make a group
420        Group group1 = groupDao.findOne(groupService.createNewGroup("Group 1",
421                user.getPrincipalName()));
422
423        // And another one which the item is not assigned to. will use to test exclusion
424        Group group2 = groupDao.findOne(groupService.createNewGroup("Group 2",
425                user.getPrincipalName()));
426
427        // Make user members of the same group
428        groupService.makeMember(user.getPrincipalName(), group1.getName());
429        // Make user members of the same group
430        groupService.makeMember(user.getPrincipalName(), group2.getName());
431
432        // Make a profile that belongs to user
433        BaseDescription profileDescription= makeTestProfile("4567", false,
434                user.getId().longValue());
435
436        // Make a profile that belongs to user, but that one will belong to group2
437        BaseDescription profileDescription2= makeTestProfile("666", false,
438                user.getId().longValue());
439
440        // user transfers ownership of the profile to his group
441        groupService.transferItemOwnershipFromUserToGroup(
442                user.getPrincipalName(), group1.getName(),
443                profileDescription.getId());
444
445        // user transfers ownership of the profile to his group
446        groupService.transferItemOwnershipFromUserToGroup(
447                user.getPrincipalName(), group2.getName(),
448                profileDescription2.getId());
449
450        List<Group> groups = groupService.getGroupsTheItemIsAMemberOf(profileDescription.getId());
451        assertEquals(1, groups.size());
452        Group g = groups.get(0);
453        assertEquals(group1.getId(), g.getId());
454    }
455}
Note: See TracBrowser for help on using the repository browser.