This project has retired. For details please refer to its
Attic page.
AclTest xref
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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);
156 final InMemoryAce aceRCopy = new InMemoryAce(BERTA, Permission.READ);
157 final InMemoryAce aceChange = new InMemoryAce(CHRISTIAN, Permission.ALL);
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 }