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

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

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