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

Last change on this file since 4098 was 4098, checked in by George.Georgovassilis@mpi.nl, 10 years ago

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