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.shiro.authz.permission;
20  
21  import static org.junit.Assert.assertFalse;
22  import static org.junit.Assert.assertTrue;
23  import org.junit.Test;
24  
25  
26  /**
27   * @since 0.9
28   */
29  public class WildcardPermissionTest {
30  
31      @Test(expected = IllegalArgumentException.class)
32      public void testNull() {
33          new WildcardPermission(null);
34      }
35  
36      @Test(expected = IllegalArgumentException.class)
37      public void testEmpty() {
38          new WildcardPermission("");
39      }
40  
41      @Test(expected = IllegalArgumentException.class)
42      public void testBlank() {
43          new WildcardPermission("   ");
44      }
45  
46      @Test(expected = IllegalArgumentException.class)
47      public void testOnlyDelimiters() {
48          new WildcardPermission("::,,::,:");
49      }
50  
51      @Test
52      public void testNamed() {
53          WildcardPermission p1, p2;
54  
55          // Case insensitive, same
56          p1 = new WildcardPermission("something");
57          p2 = new WildcardPermission("something");
58          assertTrue(p1.implies(p2));
59          assertTrue(p2.implies(p1));
60  
61          // Case insensitive, different case
62          p1 = new WildcardPermission("something");
63          p2 = new WildcardPermission("SOMETHING");
64          assertTrue(p1.implies(p2));
65          assertTrue(p2.implies(p1));
66  
67          // Case insensitive, different word
68          p1 = new WildcardPermission("something");
69          p2 = new WildcardPermission("else");
70          assertFalse(p1.implies(p2));
71          assertFalse(p2.implies(p1));
72  
73          // Case sensitive same
74          p1 = new WildcardPermission("BLAHBLAH", false);
75          p2 = new WildcardPermission("BLAHBLAH", false);
76          assertTrue(p1.implies(p2));
77          assertTrue(p2.implies(p1));
78  
79          // Case sensitive, different case
80          p1 = new WildcardPermission("BLAHBLAH", false);
81          p2 = new WildcardPermission("bLAHBLAH", false);
82          assertTrue(p1.implies(p2));
83          assertTrue(p2.implies(p1));
84  
85          // Case sensitive, different word
86          p1 = new WildcardPermission("BLAHBLAH", false);
87          p2 = new WildcardPermission("whatwhat", false);
88          assertFalse(p1.implies(p2));
89          assertFalse(p2.implies(p1));
90  
91      }
92  
93      @Test
94      public void testLists() {
95          WildcardPermission p1, p2, p3;
96  
97          p1 = new WildcardPermission("one,two");
98          p2 = new WildcardPermission("one");
99          assertTrue(p1.implies(p2));
100         assertFalse(p2.implies(p1));
101 
102         p1 = new WildcardPermission("one,two,three");
103         p2 = new WildcardPermission("one,three");
104         assertTrue(p1.implies(p2));
105         assertFalse(p2.implies(p1));
106 
107         p1 = new WildcardPermission("one,two:one,two,three");
108         p2 = new WildcardPermission("one:three");
109         p3 = new WildcardPermission("one:two,three");
110         assertTrue(p1.implies(p2));
111         assertFalse(p2.implies(p1));
112         assertTrue(p1.implies(p3));
113         assertFalse(p2.implies(p3));
114         assertTrue(p3.implies(p2));
115 
116         p1 = new WildcardPermission("one,two,three:one,two,three:one,two");
117         p2 = new WildcardPermission("one:three:two");
118         assertTrue(p1.implies(p2));
119         assertFalse(p2.implies(p1));
120 
121         p1 = new WildcardPermission("one");
122         p2 = new WildcardPermission("one:two,three,four");
123         p3 = new WildcardPermission("one:two,three,four:five:six:seven");
124         assertTrue(p1.implies(p2));
125         assertTrue(p1.implies(p3));
126         assertFalse(p2.implies(p1));
127         assertFalse(p3.implies(p1));
128         assertTrue(p2.implies(p3));
129     }
130 
131     /**
132      * Validates WildcardPermissions with that contain the same list parts are equal.
133      */
134     @Test
135     public void testListDifferentOrder() {
136 
137         WildcardPermission p6 = new WildcardPermission("one,two:three,four");
138         WildcardPermission p6DiffOrder = new WildcardPermission("two,one:four,three");
139         assertTrue(p6.equals(p6DiffOrder));
140     }
141 
142     @Test
143     public void testWildcards() {
144         WildcardPermission p1, p2, p3, p4, p5, p6, p7, p8;
145 
146         p1 = new WildcardPermission("*");
147         p2 = new WildcardPermission("one");
148         p3 = new WildcardPermission("one:two");
149         p4 = new WildcardPermission("one,two:three,four");
150         p5 = new WildcardPermission("one,two:three,four,five:six:seven,eight");
151         assertTrue(p1.implies(p2));
152         assertTrue(p1.implies(p3));
153         assertTrue(p1.implies(p4));
154         assertTrue(p1.implies(p5));
155 
156         p1 = new WildcardPermission("newsletter:*");
157         p2 = new WildcardPermission("newsletter:read");
158         p3 = new WildcardPermission("newsletter:read,write");
159         p4 = new WildcardPermission("newsletter:*");
160         p5 = new WildcardPermission("newsletter:*:*");
161         p6 = new WildcardPermission("newsletter:*:read");
162         p7 = new WildcardPermission("newsletter:write:*");
163         p8 = new WildcardPermission("newsletter:read,write:*");
164         assertTrue(p1.implies(p2));
165         assertTrue(p1.implies(p3));
166         assertTrue(p1.implies(p4));
167         assertTrue(p1.implies(p5));
168         assertTrue(p1.implies(p6));
169         assertTrue(p1.implies(p7));
170         assertTrue(p1.implies(p8));
171 
172 
173         p1 = new WildcardPermission("newsletter:*:*");
174         assertTrue(p1.implies(p2));
175         assertTrue(p1.implies(p3));
176         assertTrue(p1.implies(p4));
177         assertTrue(p1.implies(p5));
178         assertTrue(p1.implies(p6));
179         assertTrue(p1.implies(p7));
180         assertTrue(p1.implies(p8));
181 
182         p1 = new WildcardPermission("newsletter:*:*:*");
183         assertTrue(p1.implies(p2));
184         assertTrue(p1.implies(p3));
185         assertTrue(p1.implies(p4));
186         assertTrue(p1.implies(p5));
187         assertTrue(p1.implies(p6));
188         assertTrue(p1.implies(p7));
189         assertTrue(p1.implies(p8));
190 
191         p1 = new WildcardPermission("newsletter:*:read");
192         p2 = new WildcardPermission("newsletter:123:read");
193         p3 = new WildcardPermission("newsletter:123,456:read,write");
194         p4 = new WildcardPermission("newsletter:read");
195         p5 = new WildcardPermission("newsletter:read,write");
196         p6 = new WildcardPermission("newsletter:123:read:write");
197         assertTrue(p1.implies(p2));
198         assertFalse(p1.implies(p3));
199         assertFalse(p1.implies(p4));
200         assertFalse(p1.implies(p5));
201         assertTrue(p1.implies(p6));
202 
203         p1 = new WildcardPermission("newsletter:*:read:*");
204         assertTrue(p1.implies(p2));
205         assertTrue(p1.implies(p6));
206 
207     }
208 
209     @Test
210     public void testToString() {
211         WildcardPermission p1 = new WildcardPermission("*");
212         WildcardPermission p2 = new WildcardPermission("one");
213         WildcardPermission p3 = new WildcardPermission("one:two");
214         WildcardPermission p4 = new WildcardPermission("one,two:three,four");
215         WildcardPermission p5 = new WildcardPermission("one,two:three,four,five:six:seven,eight");
216 
217         assertTrue("*".equals(p1.toString()));
218         assertTrue(p1.equals(new WildcardPermission(p1.toString())));
219         assertTrue("one".equals(p2.toString()));
220         assertTrue(p2.equals(new WildcardPermission(p2.toString())));
221         assertTrue("one:two".equals(p3.toString()));
222         assertTrue(p3.equals(new WildcardPermission(p3.toString())));
223         assertTrue("one,two:three,four".equals(p4.toString()));
224         assertTrue(p4.equals(new WildcardPermission(p4.toString())));
225         assertTrue("one,two:three,four,five:six:seven,eight".equals(p5.toString()));
226         assertTrue(p5.equals(new WildcardPermission(p5.toString())));
227     }
228 }