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 org.junit.Test;
22  
23  import java.util.Iterator;
24  import java.util.List;
25  import java.util.Set;
26  
27  import static org.junit.Assert.*;
28  import static org.junit.Assert.assertEquals;
29  
30  /**
31   * @since 1.3
32   */
33  public class DomainPermissionTest {
34      @Test
35      public void testDefaultConstructor() {
36          DomainPermission p;
37          List<Set<String>> parts;
38          Set<String> set;
39          String entry;
40  
41          // No arg constructor
42          p = new DomainPermission();
43  
44          // Verify domain
45          assertTrue("domain".equals(p.getDomain()));
46  
47          // Verify actions
48          set = p.getActions();
49          assertNull(set);
50  
51          // Verify targets
52          set = p.getTargets();
53          assertNull(set);
54  
55          // Verify parts
56          parts = p.getParts();
57          assertEquals("Number of parts", 1, parts.size());
58          set = parts.get(0);
59          assertEquals(1, set.size());
60          entry = set.iterator().next();
61          assertEquals("domain", entry);
62      }
63  
64      @Test
65      public void testActionsConstructorWithSingleAction() {
66          DomainPermission p;
67          List<Set<String>> parts;
68          Set<String> set;
69          Iterator<String> iterator;
70          String entry;
71  
72          // Actions constructor with a single action
73          p = new DomainPermission("action1");
74  
75          // Verify domain
76          assertEquals("domain", p.getDomain());
77  
78          // Verify actions
79          set = p.getActions();
80          assertNotNull(set);
81          assertEquals(1, set.size());
82          iterator = set.iterator();
83          entry = iterator.next();
84          assertEquals("action1", entry);
85  
86          // Verify targets
87          set = p.getTargets();
88          assertNull(set);
89  
90          // Verify parts
91          parts = p.getParts();
92          assertEquals(2, parts.size());
93          set = parts.get(0);
94          assertEquals(1, set.size());
95          iterator = set.iterator();
96          entry = iterator.next();
97          assertEquals("domain", entry);
98          set = parts.get(1);
99          assertEquals(1, set.size());
100         iterator = set.iterator();
101         entry = iterator.next();
102         assertEquals("action1", entry);
103     }
104 
105     @Test
106     public void testActionsConstructorWithMultipleActions() {
107         DomainPermission p;
108         List<Set<String>> parts;
109         Set<String> set;
110         Iterator<String> iterator;
111         String entry;
112 
113         // Actions constructor with three actions
114         p = new DomainPermission("action1,action2,action3");
115 
116         // Verify domain
117         assertEquals("domain", p.getDomain());
118 
119         // Verify actions
120         set = p.getActions();
121         assertNotNull(set);
122         assertEquals(3, set.size());
123         iterator = set.iterator();
124         entry = iterator.next();
125         assertEquals("action1", entry);
126         entry = iterator.next();
127         assertEquals("action2", entry);
128         entry = iterator.next();
129         assertEquals("action3", entry);
130 
131         // Verify targets
132         set = p.getTargets();
133         assertNull(set);
134 
135         // Verify parts
136         parts = p.getParts();
137         assertEquals(2, parts.size());
138         set = parts.get(0);
139         assertEquals(1, set.size());
140         iterator = set.iterator();
141         entry = iterator.next();
142         assertEquals("domain", entry);
143         set = parts.get(1);
144         assertEquals(3, set.size());
145         iterator = set.iterator();
146         entry = iterator.next();
147         assertEquals("action1", entry);
148         entry = iterator.next();
149         assertEquals("action2", entry);
150         entry = iterator.next();
151         assertEquals("action3", entry);
152     }
153 
154     @Test
155     public void testActionsTargetsConstructorWithSingleActionAndTarget() {
156         DomainPermission p;
157         List<Set<String>> parts;
158         Set<String> set;
159         Iterator<String> iterator;
160         String entry;
161 
162         // Actions and target constructor with a single action and target
163         p = new DomainPermission("action1", "target1");
164 
165         // Verify domain
166         assertEquals("domain", p.getDomain());
167 
168         // Verify actions
169         set = p.getActions();
170         assertNotNull(set);
171         assertEquals(1, set.size());
172         iterator = set.iterator();
173         entry = iterator.next();
174         assertEquals("action1", entry);
175 
176         // Verify targets
177         set = p.getTargets();
178         assertNotNull(set);
179         assertEquals(1, set.size());
180         iterator = set.iterator();
181         entry = iterator.next();
182         assertEquals("target1", entry);
183 
184         // Verify parts
185         parts = p.getParts();
186         assertEquals(3, parts.size());
187         set = parts.get(0);
188         assertEquals(1, set.size());
189         iterator = set.iterator();
190         entry = iterator.next();
191         assertEquals("domain", entry);
192         set = parts.get(1);
193         assertEquals(1, set.size());
194         iterator = set.iterator();
195         entry = iterator.next();
196         assertEquals("action1", entry);
197         set = parts.get(2);
198         assertEquals(1, set.size());
199         iterator = set.iterator();
200         entry = iterator.next();
201         assertEquals("target1", entry);
202     }
203 
204     @Test
205     public void testActionsTargetsConstructorWithMultipleActionsAndTargets() {
206         DomainPermission p;
207         List<Set<String>> parts;
208         Set<String> set;
209         Iterator<String> iterator;
210         String entry;
211 
212         // Actions and target constructor with a single action and target
213         p = new DomainPermission("action1,action2,action3", "target1,target2,target3");
214 
215         // Verify domain
216         assertEquals("domain", p.getDomain());
217 
218         // Verify actions
219         set = p.getActions();
220         assertNotNull(set);
221         assertEquals(3, set.size());
222         iterator = set.iterator();
223         entry = iterator.next();
224         assertEquals("action1", entry);
225         entry = iterator.next();
226         assertEquals("action2", entry);
227         entry = iterator.next();
228         assertEquals("action3", entry);
229 
230         // Verify targets
231         set = p.getTargets();
232         assertNotNull(set);
233         assertEquals(3, set.size());
234         iterator = set.iterator();
235         entry = iterator.next();
236         assertEquals("target1", entry);
237         entry = iterator.next();
238         assertEquals("target2", entry);
239         entry = iterator.next();
240         assertEquals("target3", entry);
241 
242         // Verify parts
243         parts = p.getParts();
244         assertEquals(3, parts.size());
245         set = parts.get(0);
246         assertEquals(1, set.size());
247         iterator = set.iterator();
248         entry = iterator.next();
249         assertEquals("domain", entry);
250         set = parts.get(1);
251         assertEquals(3, set.size());
252         iterator = set.iterator();
253         entry = iterator.next();
254         assertEquals("action1", entry);
255         entry = iterator.next();
256         assertEquals("action2", entry);
257         entry = iterator.next();
258         assertEquals("action3", entry);
259         set = parts.get(2);
260         assertEquals(3, set.size());
261         iterator = set.iterator();
262         entry = iterator.next();
263         assertEquals("target1", entry);
264         entry = iterator.next();
265         assertEquals("target2", entry);
266         entry = iterator.next();
267         assertEquals("target3", entry);
268     }
269 }