1 /*Copyright (C) 2014 Red Hat, Inc.
2 
3 This file is part of IcedTea.
4 
5 IcedTea is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 2.
8 
9 IcedTea is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 General Public License for more details.
13 
14 You should have received a copy of the GNU General Public License
15 along with IcedTea; see the file COPYING.  If not, write to
16 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 02110-1301 USA.
18 
19 Linking this library statically or dynamically with other modules is
20 making a combined work based on this library.  Thus, the terms and
21 conditions of the GNU General Public License cover the whole
22 combination.
23 
24 As a special exception, the copyright holders of this library give you
25 permission to link this library with independent modules to produce an
26 executable, regardless of the license terms of these independent
27 modules, and to copy and distribute the resulting executable under
28 terms of your choice, provided that you also meet, for each linked
29 independent module, the terms and conditions of the license of that
30 module.  An independent module is a module which is not derived from
31 or based on this library.  If you modify this library, you may extend
32 this exception to your version of the library, but you are not
33 obligated to do so.  If you do not wish to do so, delete this
34 exception statement from your version.
35  */
36 
37 package net.sourceforge.jnlp.security.policyeditor;
38 
39 import net.sourceforge.jnlp.util.FileUtils;
40 import org.junit.Before;
41 import org.junit.Test;
42 
43 import java.io.File;
44 import java.util.Collection;
45 import java.util.Collections;
46 import java.util.HashSet;
47 import java.util.Map;
48 import java.util.Set;
49 
50 import static org.junit.Assert.assertEquals;
51 import static org.junit.Assert.assertFalse;
52 import static org.junit.Assert.assertNotEquals;
53 import static org.junit.Assert.assertTrue;
54 
55 /**
56  * See PolicyEditorParsingTest, which covers PolicyFileModel#openAndParsePolicyFile(),
57  * PolicyFileModel.parsePolicyString(), PolicyFileModel#savePolicyFile()
58  */
59 public class PolicyFileModelTest {
60 
61     private String tempFilePath;
62     private PolicyFileModel model;
63 
64     @Before
setNewTempfile()65     public void setNewTempfile() throws Exception {
66         tempFilePath = File.createTempFile("policyeditor", null).getCanonicalPath();
67         model = new PolicyFileModel();
68         model.setFile(new File(tempFilePath));
69     }
70 
71     @Test
testSetGetFile()72     public void testSetGetFile() throws Exception {
73         assertEquals(new File(tempFilePath), model.getFile());
74     }
75 
76     @Test
testSetFileNull()77     public void testSetFileNull() throws Exception {
78         model.setFile(null);
79 
80         assertEquals(null, model.getFile());
81     }
82 
83     @Test(expected = NullPointerException.class)
testOpenAndParsePolicyFileWithFileNull()84     public void testOpenAndParsePolicyFileWithFileNull() throws Exception {
85         model.setFile(null);
86 
87         assertEquals(null, model.getFile());
88         model.openAndParsePolicyFile();
89     }
90 
91     @Test(expected = NullPointerException.class)
testSavePolicyFileWithFileNull()92     public void testSavePolicyFileWithFileNull() throws Exception {
93         model.setFile(null);
94 
95         assertEquals(null, model.getFile());
96         model.savePolicyFile();
97     }
98 
99     @Test
testHasChangedIsFalseInitially()100     public void testHasChangedIsFalseInitially() throws Exception {
101         assertFalse("Model should not report changes made initially", model.hasChanged());
102     }
103 
104     @Test
testFileHasChangedWithChange()105     public void testFileHasChangedWithChange() throws Exception {
106         assertFalse("Model should not report changes made initially", model.hasChanged());
107         final String codebase = "http://example.com";
108         final PolicyEditorPermissions editorPermissions = PolicyEditorPermissions.CLIPBOARD;
109         final Collection<PolicyEditorPermissions> permissions = Collections.singleton(editorPermissions);
110         final CustomPermission customPermission = new CustomPermission(PermissionType.FILE_PERMISSION, PermissionTarget.USER_HOME, PermissionActions.FILE_ALL);
111         final Collection<CustomPermission> customPermissions = Collections.singleton(customPermission);
112         final PolicyEntry policyEntry = new PolicyEntry(codebase, permissions, customPermissions);
113         FileUtils.saveFile(policyEntry.toString(), new File(tempFilePath));
114         model.openAndParsePolicyFile();
115         final Collection<PolicyEditorPermissions> editorPermissions2 = Collections.singleton(PolicyEditorPermissions.ALL_AWT);
116         final PolicyEntry policyEntry2 = new PolicyEntry(codebase, editorPermissions2, customPermissions);
117         FileUtils.saveFile(policyEntry2.toString(), new File(tempFilePath));
118         assertTrue("File should be marked changed after being externally modified", model.hasChanged());
119     }
120 
121     @Test
testAddCodebase()122     public void testAddCodebase() throws Exception {
123         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
124         final String codebase = "http://example.com";
125         model.addCodebase(codebase);
126         assertEquals("Should have the codebase", Collections.singleton(codebase), model.getCodebases());
127     }
128 
129     @Test
testRemoveCodebase()130     public void testRemoveCodebase() throws Exception {
131         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
132         final String codebase = "http://example.com";
133         model.addCodebase(codebase);
134         assertEquals("Should have the codebase " + codebase, Collections.singleton(codebase), model.getCodebases());
135         model.removeCodebase(codebase);
136         assertEquals("Should not have any codebases after removed", Collections.emptySet(), model.getCodebases());
137     }
138 
139     @Test
testClearPermissions()140     public void testClearPermissions() throws Exception {
141         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
142         final String codebase = "http://example.com";
143         model.addCodebase(codebase);
144         final PolicyEditorPermissions permission = PolicyEditorPermissions.CLIPBOARD;
145         model.setPermission(codebase, permission, true);
146         assertTrue("Expected permission " + permission, model.getPermission(codebase, permission));
147         model.clearPermissions();
148         assertFalse("Expected no permission " + permission, model.getPermission(codebase, permission));
149         assertEquals("Expected no permissions ", Collections.emptyMap(), model.getCopyOfPermissions());
150     }
151 
152     @Test
testSettersAndGettersForPermission()153     public void testSettersAndGettersForPermission() throws Exception {
154         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
155         final String codebase = "http://example.com";
156         model.addCodebase(codebase);
157         final PolicyEditorPermissions permission = PolicyEditorPermissions.CLIPBOARD;
158         model.setPermission(codebase, permission, true);
159         assertTrue("Expected permission " + permission, model.getPermission(codebase, permission));
160     }
161 
162     @Test
testClearCustomCodebase()163     public void testClearCustomCodebase() throws Exception {
164         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
165         final String codebase = "http://example.com";
166         model.addCodebase(codebase);
167         final CustomPermission customPermission = new CustomPermission(PermissionType.FILE_PERMISSION, PermissionTarget.USER_HOME, PermissionActions.FILE_ALL);
168         final Collection<CustomPermission> customPermissions = Collections.singleton(customPermission);
169         model.addCustomPermissions(codebase, customPermissions);
170         assertEquals("Expected custom permission", customPermissions, model.getCopyOfCustomPermissions().get(codebase));
171         model.clearCustomCodebase(codebase);
172         assertEquals("Custom permissions were expected to be empty", Collections.emptySet(), model.getCopyOfCustomPermissions().get(codebase));
173     }
174 
175     @Test
testClearCustomPermission()176     public void testClearCustomPermission() throws Exception {
177         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
178         final String codebase = "http://example.com";
179         model.addCodebase(codebase);
180         final CustomPermission customPermission = new CustomPermission(PermissionType.FILE_PERMISSION, PermissionTarget.USER_HOME, PermissionActions.FILE_ALL);
181         final Collection<CustomPermission> customPermissions = Collections.singleton(customPermission);
182         model.addCustomPermissions(codebase, customPermissions);
183         assertEquals("Expected custom permission", customPermissions, model.getCopyOfCustomPermissions().get(codebase));
184         model.clearCustomPermissions();
185         assertEquals("Custom permissions were expected to be empty", null, model.getCopyOfCustomPermissions().get(codebase));
186         assertEquals("All codebase custom permissions were expected to be empty", Collections.emptyMap(), model.getCopyOfCustomPermissions());
187     }
188 
189     @Test
testAddCustomPermissions()190     public void testAddCustomPermissions() throws Exception {
191         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
192         final String codebase = "http://example.com";
193         model.addCodebase(codebase);
194         final CustomPermission customPermission = new CustomPermission(PermissionType.FILE_PERMISSION, PermissionTarget.USER_HOME, PermissionActions.FILE_ALL);
195         final Collection<CustomPermission> customPermissions = Collections.singleton(customPermission);
196         model.addCustomPermissions(codebase, customPermissions);
197         assertEquals("Expected file/user home/all-actions permission ", customPermissions, model.getCopyOfCustomPermissions().get(codebase));
198         final CustomPermission customPermission2 = new CustomPermission(PermissionType.AUDIO_PERMISSION, PermissionTarget.PLAY);
199         final Collection<CustomPermission> customPermissions2 = Collections.singleton(customPermission2);
200         model.addCustomPermissions(codebase, customPermissions2);
201         assertTrue("Expected audio play permission ", model.getCopyOfCustomPermissions().get(codebase).contains(customPermission2));
202         final HashSet<CustomPermission> customPermissionHashSet = new HashSet<>();
203         customPermissionHashSet.add(customPermission);
204         customPermissionHashSet.add(customPermission2);
205         assertEquals("Expected custom permission ", customPermissionHashSet, model.getCopyOfCustomPermissions().get(codebase));
206     }
207 
208     @Test
testAllPermissionsAreFalseInitially()209     public void testAllPermissionsAreFalseInitially() throws Exception {
210         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
211         final String codebase = "http://example.com";
212         model.addCodebase(codebase);
213         final Map<PolicyEditorPermissions, Boolean> policyEditorPermissions = model.getCopyOfPermissions().get(codebase);
214         for (final Map.Entry<PolicyEditorPermissions, Boolean> entry : policyEditorPermissions.entrySet()) {
215             assertFalse("Expected " + entry.getKey() + " to be false", entry.getValue());
216         }
217     }
218 
219     @Test
testAllPermissionsAreInitialized()220     public void testAllPermissionsAreInitialized() throws Exception {
221         assertEquals("Should not have any codebases initially", Collections.emptySet(), model.getCodebases());
222         final String codebase = "http://example.com";
223         model.addCodebase(codebase);
224         final Map<PolicyEditorPermissions, Boolean> policyEditorPermissions = model.getCopyOfPermissions().get(codebase);
225         for (final PolicyEditorPermissions perm : PolicyEditorPermissions.values()) {
226             assertTrue(perm + " should have been present as a key", policyEditorPermissions.containsKey(perm));
227         }
228     }
229 
230     @Test
testGetCopyOfPermissionsIsCopy()231     public void testGetCopyOfPermissionsIsCopy() throws Exception {
232         final Map<String, Map<PolicyEditorPermissions, Boolean>> codebasePermissionsMap = model.getCopyOfPermissions();
233         assertEquals("Map should be initially empty", Collections.emptyMap(), codebasePermissionsMap);
234         codebasePermissionsMap.put("invalid codebase", Collections.singletonMap(PolicyEditorPermissions.CLIPBOARD, true));
235         final Map<String, Map<PolicyEditorPermissions, Boolean>> codebasePermissionsMap2 = model.getCopyOfPermissions();
236         assertEquals("New copy should be initially empty", Collections.emptyMap(), codebasePermissionsMap2);
237         assertNotEquals("Modified map should not equal newly copied map", codebasePermissionsMap, codebasePermissionsMap2);
238     }
239 
240     @Test
testGetCopyOfCustomPermissionsIsCopy()241     public void testGetCopyOfCustomPermissionsIsCopy() throws Exception {
242         final Map<String, Set<CustomPermission>> codebasePermissionsMap = model.getCopyOfCustomPermissions();
243         assertEquals("Map should be initially empty", Collections.emptyMap(), codebasePermissionsMap);
244         codebasePermissionsMap.put("invalid codebase", Collections.singleton(new CustomPermission(PermissionType.AUDIO_PERMISSION, PermissionTarget.PLAY)));
245         final Map<String, Set<CustomPermission>> codebasePermissionsMap2 = model.getCopyOfCustomPermissions();
246         assertEquals("New copy should be initially empty", Collections.emptyMap(), codebasePermissionsMap2);
247         assertNotEquals("Modified set should not equal newly copied set", codebasePermissionsMap, codebasePermissionsMap2);
248     }
249 }
250