This project has retired. For details please refer to its Attic page.
AclTest xref

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.chemistry.opencmis.inmemory;
20  
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertTrue;
24  import static org.junit.Assert.fail;
25  
26  import java.util.ArrayList;
27  import java.util.Arrays;
28  import java.util.List;
29  
30  import org.apache.chemistry.opencmis.commons.data.Ace;
31  import org.apache.chemistry.opencmis.commons.data.Acl;
32  import org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlEntryImpl;
33  import org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlListImpl;
34  import org.apache.chemistry.opencmis.commons.impl.dataobjects.AccessControlPrincipalDataImpl;
35  import org.apache.chemistry.opencmis.commons.impl.jaxb.EnumBasicPermissions;
36  import org.apache.chemistry.opencmis.inmemory.storedobj.impl.InMemoryAce;
37  import org.apache.chemistry.opencmis.inmemory.storedobj.impl.InMemoryAcl;
38  import org.apache.chemistry.opencmis.inmemory.storedobj.impl.Permission;
39  import org.apache.commons.logging.Log;
40  import org.apache.commons.logging.LogFactory;
41  import org.junit.Test;
42  
43  public class AclTest {
44  
45      private static final Log LOG = LogFactory.getLog(AclTest.class);
46  
47      final static String ANDREAS = "andreas";
48      final static String BERTA = "berta";
49      final static String CHRISTIAN = "christian";
50      final static String DOROTHEE = "dorothee";
51      
52      final InMemoryAce aceN = new InMemoryAce(ANDREAS, Permission.NONE);
53      final InMemoryAce aceR = new InMemoryAce(BERTA, Permission.READ);
54      final InMemoryAce aceW = new InMemoryAce(CHRISTIAN, Permission.WRITE);
55      final InMemoryAce aceA = new InMemoryAce(DOROTHEE, Permission.ALL);
56  
57      @Test
58      public void testCreateAce() {
59          InMemoryAce ace;
60          try {
61              ace = new InMemoryAce(null, Permission.NONE);
62              fail("create an ACE with null principalId should fail.");
63          } catch (RuntimeException e) {            
64          }
65  
66          try {
67              ace = new InMemoryAce("xxx", null);
68              fail("create an ACE with null permission should fail.");
69          } catch (RuntimeException e) {            
70          }
71  
72      }
73      
74      @Test
75      public void testCreate() {
76      
77          InMemoryAcl acl = new InMemoryAcl();
78          acl.addAce(aceA);
79          assertEquals(1, acl.getAces().size());
80          assertTrue(acl.getAces().get(0) == aceA);
81      
82          acl = new InMemoryAcl(createAceList());
83          LOG.debug(acl);
84          
85          assertEquals(2, acl.getAces().size());
86          assertTrue(acl.getAces().get(0) == aceR);
87          assertTrue(acl.getAces().get(1) == aceA);
88      
89          acl = createDefaultAcl();
90          checkDefaultAcl(acl);
91          
92          try {
93              List<InMemoryAce> aces = createAceList();
94              aces.add(null);
95              acl = new InMemoryAcl(aces);
96              fail("create an ACL with a null ACE should fail.");
97          } catch (RuntimeException e) {            
98          }
99      }
100     
101     @Test
102     public void testAdd() {
103         InMemoryAcl acl = new InMemoryAcl();
104         acl.addAce(aceR);
105         assertEquals(1, acl.getAces().size());
106         assertTrue(acl.getAces().get(0) == aceR);
107         acl.addAce(aceW);
108         assertEquals(2, acl.getAces().size());
109         assertTrue(acl.getAces().get(0) == aceR);
110         assertTrue(acl.getAces().get(1) == aceW);
111         acl.addAce(aceN);
112         assertEquals(3, acl.getAces().size());
113         assertTrue(acl.getAces().get(0) == aceN);
114         assertTrue(acl.getAces().get(1) == aceR);
115         assertTrue(acl.getAces().get(2) == aceW);
116         acl.addAce(aceA);
117         assertEquals(4, acl.getAces().size());
118         assertTrue(acl.getAces().get(0) == aceN);
119         assertTrue(acl.getAces().get(1) == aceR);
120         assertTrue(acl.getAces().get(2) == aceW);
121         assertTrue(acl.getAces().get(3) == aceA);    
122 
123         assertFalse("Adding an existing ACE to an ACL should fail.", acl.addAce(aceN));
124         assertFalse("Adding null to an ACL should fail.", acl.addAce(null));
125     }
126     
127     @Test
128     public void testRemove() {
129         InMemoryAcl acl = createDefaultAcl();
130         checkDefaultAcl(acl);
131 
132         acl.removeAce(aceR);
133         assertEquals(3, acl.getAces().size());
134         assertTrue(acl.getAces().get(0) == aceN);
135         assertTrue(acl.getAces().get(1) == aceW);
136         assertTrue(acl.getAces().get(2) == aceA);
137         acl.removeAce(aceW);
138         assertEquals(2, acl.getAces().size());
139         assertTrue(acl.getAces().get(0) == aceN);
140         assertTrue(acl.getAces().get(1) == aceA);
141         acl.removeAce(aceN);
142         assertEquals(1, acl.getAces().size());
143         assertTrue(acl.getAces().get(0) == aceA);
144         acl.removeAce(aceA);
145         assertEquals(0, acl.getAces().size());
146         
147         acl = createDefaultAcl();
148         final InMemoryAce ace = new InMemoryAce("xyu", Permission.ALL);
149         assertFalse("Removing an unknown ACE from an ACL should fail.", acl.removeAce(ace));
150         assertFalse("Removing null from an ACL should fail.", acl.removeAce(null));
151     }
152 
153     @Test
154     public void testMerge() {
155         final InMemoryAce aceNew = new InMemoryAce("Hugo", Permission.WRITE); // will be added
156         final InMemoryAce aceRCopy = new InMemoryAce(BERTA, Permission.READ); // is same
157         final InMemoryAce aceChange = new InMemoryAce(CHRISTIAN, Permission.ALL); // changes permission
158 
159         InMemoryAcl acl1 = createDefaultAcl();
160         InMemoryAcl acl2 = new InMemoryAcl(new ArrayList<InMemoryAce>() {{ add(aceNew); add(aceRCopy);  add(aceChange); }});
161         acl1.mergeAcl(acl2);
162         assertEquals(5, acl1.getAces().size());
163         assertEquals(Permission.NONE, acl1.getPermission(ANDREAS));
164         assertEquals(Permission.READ, acl1.getPermission(BERTA));
165         assertEquals(Permission.ALL, acl1.getPermission(CHRISTIAN));
166         assertEquals(Permission.ALL, acl1.getPermission(DOROTHEE));
167         assertEquals(Permission.WRITE, acl1.getPermission("Hugo"));
168     }
169     
170     @Test
171     public void testAclEquality() {
172         final InMemoryAce aceNew = new InMemoryAce("Hugo", Permission.WRITE);
173         final InMemoryAce aceRCopy = new InMemoryAce(BERTA, Permission.READ);
174 
175         InMemoryAcl acl1 = createDefaultAcl();
176         InMemoryAcl acl2 = new InMemoryAcl(new ArrayList<InMemoryAce>() {{ add(aceRCopy); add(aceA);  add(aceW);  add(aceN); }});
177         InMemoryAcl acl3 = new InMemoryAcl(new ArrayList<InMemoryAce>() {{ add(aceR); add(aceNew);  add(aceW);  add(aceN); }});
178         assertEquals(acl1, acl2);
179         assertFalse(acl1.equals(acl3));      
180     }
181     
182     
183     @Test
184     public void testCheckPermissions() {
185         InMemoryAcl acl = createDefaultAcl();
186 
187         assertTrue(acl.hasPermission(ANDREAS, Permission.NONE));
188         assertFalse(acl.hasPermission(ANDREAS, Permission.READ));
189         assertFalse(acl.hasPermission(ANDREAS, Permission.WRITE));
190         assertFalse(acl.hasPermission(ANDREAS, Permission.ALL));
191 
192         assertTrue(acl.hasPermission(BERTA, Permission.NONE));
193         assertTrue(acl.hasPermission(BERTA, Permission.READ));
194         assertFalse(acl.hasPermission(BERTA, Permission.WRITE));
195         assertFalse(acl.hasPermission(BERTA, Permission.ALL));
196     
197         assertTrue(acl.hasPermission(CHRISTIAN, Permission.NONE));
198         assertTrue(acl.hasPermission(CHRISTIAN, Permission.READ));
199         assertTrue(acl.hasPermission(CHRISTIAN, Permission.WRITE));
200         assertFalse(acl.hasPermission(CHRISTIAN, Permission.ALL));
201 
202         assertTrue(acl.hasPermission(DOROTHEE, Permission.NONE));
203         assertTrue(acl.hasPermission(DOROTHEE, Permission.READ));
204         assertTrue(acl.hasPermission(DOROTHEE, Permission.WRITE));
205         assertTrue(acl.hasPermission(DOROTHEE, Permission.ALL));
206     }
207 
208     @Test
209     public void testConvertFomCmisAcl() {
210         List<Ace> aces = Arrays.asList(new Ace[] { createAce(ANDREAS, EnumBasicPermissions.CMIS_READ.value()), createAce(DOROTHEE, EnumBasicPermissions.CMIS_WRITE.value()) });
211         AccessControlListImpl cAcl = new AccessControlListImpl(aces);
212         InMemoryAcl acl = InMemoryAcl.createFromCommonsAcl(cAcl);        
213         assertEquals(2, acl.size());
214         assertEquals(Permission.READ, acl.getPermission(ANDREAS));
215         assertEquals(Permission.WRITE, acl.getPermission(DOROTHEE));
216         
217         try {
218             List<Ace> aces2 = Arrays.asList(new Ace[] { new AccessControlEntryImpl(null,  Arrays.asList(new String[] { EnumBasicPermissions.CMIS_READ.value()}))});
219             acl = InMemoryAcl.createFromCommonsAcl(new AccessControlListImpl(aces2));
220             fail("create Ace will null principal should raise exception.");
221         } catch (RuntimeException e) { }
222         try {
223             List<Ace> aces2 = Arrays.asList(new Ace[] { new AccessControlEntryImpl(new AccessControlPrincipalDataImpl(ANDREAS),  null)});
224             acl = InMemoryAcl.createFromCommonsAcl(new AccessControlListImpl(aces2));
225             fail("create Ace will null permission should raise exception.");
226         } catch (RuntimeException e) { }
227     }
228     
229     
230     @Test
231     public void testConvertToCmisAcl() {
232         Ace ace = aceN.toCommonsAce();
233         assertEquals(ANDREAS, ace.getPrincipalId());
234         assertEquals(1, ace.getPermissions().size());
235         assertEquals("", ace.getPermissions().get(0));
236 
237         ace = aceR.toCommonsAce();
238         assertEquals(BERTA, ace.getPrincipalId());
239         assertEquals(1, ace.getPermissions().size());
240         assertEquals(EnumBasicPermissions.CMIS_READ.value(), ace.getPermissions().get(0));
241 
242         ace = aceW.toCommonsAce();
243         assertEquals(CHRISTIAN, ace.getPrincipalId());
244         assertEquals(1, ace.getPermissions().size());
245         assertEquals(EnumBasicPermissions.CMIS_WRITE.value(), ace.getPermissions().get(0));
246 
247         ace = aceA.toCommonsAce();
248         assertEquals(DOROTHEE, ace.getPrincipalId());
249         assertEquals(1, ace.getPermissions().size());
250         assertEquals(EnumBasicPermissions.CMIS_ALL.value(), ace.getPermissions().get(0));
251         
252         InMemoryAcl acl = createDefaultAcl();
253         Acl commonsAcl = acl.toCommonsAcl();
254         assertEquals(4, commonsAcl.getAces().size());
255         assertTrue(hasCommonsAce(commonsAcl, ANDREAS, ""));
256         assertFalse(hasCommonsAce(commonsAcl, ANDREAS, EnumBasicPermissions.CMIS_READ.value()));
257         assertFalse(hasCommonsAce(commonsAcl, ANDREAS, EnumBasicPermissions.CMIS_WRITE.value()));
258         assertFalse(hasCommonsAce(commonsAcl, ANDREAS, EnumBasicPermissions.CMIS_ALL.value()));
259         assertTrue(hasCommonsAce(commonsAcl, BERTA, EnumBasicPermissions.CMIS_READ.value()));
260         assertTrue(hasCommonsAce(commonsAcl, CHRISTIAN, EnumBasicPermissions.CMIS_WRITE.value()));
261         assertTrue(hasCommonsAce(commonsAcl, DOROTHEE, EnumBasicPermissions.CMIS_ALL.value()));
262     }
263     
264     @Test
265     public void testCloneAcl() {
266         InMemoryAcl acl = createDefaultAcl();
267         InMemoryAcl acl2 = acl.clone();
268         assertFalse(acl == acl2);
269         assertEquals(acl, acl2);
270     }
271     
272     private InMemoryAcl createDefaultAcl() {
273         return  new InMemoryAcl(new ArrayList<InMemoryAce>() {{ add(aceA); add(aceR);  add(aceN);  add(aceW); }});
274     }
275     
276     private void checkDefaultAcl(InMemoryAcl acl) {
277         assertEquals(4, acl.getAces().size());
278         assertTrue(acl.getAces().get(0) == aceN);
279         assertTrue(acl.getAces().get(1) == aceR);
280         assertTrue(acl.getAces().get(2) == aceW);
281         assertTrue(acl.getAces().get(3) == aceA);        
282     }
283 
284     private List<InMemoryAce> createAceList() {
285         return new ArrayList<InMemoryAce>() {{ add(aceA); add(aceR); }};
286     }
287     
288     private Ace createAce(String principalId, String permission) {
289         AccessControlEntryImpl ace = new AccessControlEntryImpl(new AccessControlPrincipalDataImpl(principalId),
290                 Arrays.asList(new String[] { permission }));
291         return ace;
292     }
293 
294     private boolean hasCommonsAce(Acl acl, String principalId, String permission) {
295         for (Ace ace : acl.getAces()) {
296             if (ace.getPrincipalId().equals(principalId) && ace.getPermissions().get(0).equals(permission))
297                 return true;
298         }
299         return false;
300         
301     }
302 }