001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Alexey V. Varlamov
020: * @version $Revision$
021: */package org.apache.harmony.security.tests.fortress;
022:
023: import java.net.URL;
024: import java.security.cert.Certificate;
025: import java.security.CodeSource;
026: import java.security.Permission;
027: import java.security.PermissionCollection;
028: import java.security.Principal;
029: import java.security.ProtectionDomain;
030: import java.security.SecurityPermission;
031: import java.util.Arrays;
032: import java.util.Collection;
033: import java.util.HashSet;
034: import java.util.Properties;
035:
036: import org.apache.harmony.security.PolicyEntry;
037: import org.apache.harmony.security.UnresolvedPrincipal;
038: import org.apache.harmony.security.fortress.DefaultPolicy;
039: import org.apache.harmony.security.fortress.DefaultPolicyParser;
040: import junit.framework.TestCase;
041:
042: /**
043: * Tests for DefaultPolicy
044: *
045: */
046: public class DefaultPolicyTest extends TestCase {
047:
048: public static void main(String[] args) {
049: junit.textui.TestRunner.run(DefaultPolicyTest.class);
050: }
051:
052: static class TestParser extends DefaultPolicyParser {
053:
054: PolicyEntry[] content;
055:
056: public TestParser(PolicyEntry[] content) {
057: this .content = content;
058: }
059:
060: public Collection parse(URL location, Properties system)
061: throws Exception {
062: if (content != null) {
063: return Arrays.asList(content);
064: }
065: throw new RuntimeException();
066: }
067: }
068:
069: /**
070: * Tests that policy is really resetted on refresh().
071: */
072: public void testRefresh() {
073: Permission sp = new SecurityPermission("sdf");
074: PolicyEntry[] pe = new PolicyEntry[] { new PolicyEntry(null,
075: null, Arrays.asList(new Permission[] { sp })) };
076: TestParser tp = new TestParser(pe);
077: DefaultPolicy policy = new DefaultPolicy(tp);
078: CodeSource cs = new CodeSource(null, (Certificate[]) null);
079: assertTrue(policy.getPermissions(cs).implies(sp));
080:
081: tp.content = new PolicyEntry[0];
082: policy.refresh();
083: assertFalse(policy.getPermissions(cs).implies(sp));
084:
085: tp.content = null;
086: policy.refresh();
087: assertFalse(policy.getPermissions(cs).implies(sp));
088: }
089:
090: /**
091: * Tests that refresh() does not fail on failing parser.
092: */
093: public void testRefresh_Failure() {
094: CodeSource cs = new CodeSource(null, (Certificate[]) null);
095: DefaultPolicy policy = new DefaultPolicy(new TestParser(null));
096: policy.refresh();
097: assertFalse(policy.getPermissions(cs).elements()
098: .hasMoreElements());
099: }
100:
101: /**
102: * Tests proper policy evaluation for CodeSource parameters.
103: */
104: public void testGetPermissions_CodeSource() throws Exception {
105: CodeSource cs = new CodeSource(null, (Certificate[]) null);
106: CodeSource cs2 = new CodeSource(new URL("http://a.b.c"),
107: (Certificate[]) null);
108: Permission sp1 = new SecurityPermission("aaa");
109: Permission sp2 = new SecurityPermission("bbb");
110: Permission sp3 = new SecurityPermission("ccc");
111: PolicyEntry pe1 = new PolicyEntry(cs, null, Arrays
112: .asList(new Permission[] { sp1 }));
113: PolicyEntry pe2 = new PolicyEntry(cs2, new HashSet(), Arrays
114: .asList(new Permission[] { sp2 }));
115: PolicyEntry pe3 = new PolicyEntry(cs, Arrays
116: .asList(new Principal[] { new FakePrincipal("qqq") }),
117: Arrays.asList(new Permission[] { sp3 }));
118: PolicyEntry[] peArray = new PolicyEntry[] { pe1, pe2, pe3 };
119: DefaultPolicy policy = new DefaultPolicy(
120: new TestParser(peArray));
121:
122: assertTrue(policy.getPermissions(cs).implies(sp1));
123: assertFalse(policy.getPermissions(cs).implies(sp2));
124: assertFalse(policy.getPermissions(cs).implies(sp3));
125:
126: assertTrue(policy.getPermissions(cs2).implies(sp1));
127: assertTrue(policy.getPermissions(cs2).implies(sp2));
128: assertFalse(policy.getPermissions(cs2).implies(sp3));
129: }
130:
131: /**
132: * Tests proper policy evaluation for ProtectionDomain parameters.
133: */
134: public void testGetPermissions_ProtectionDomain() throws Exception {
135: Permission sp1 = new SecurityPermission("aaa");
136: Permission sp2 = new SecurityPermission("bbb");
137: Permission sp3 = new SecurityPermission("ccc");
138: Permission sp4 = new SecurityPermission("ddd");
139: Permission spZ = new SecurityPermission("zzz");
140: PermissionCollection pcZ = spZ.newPermissionCollection();
141: pcZ.add(spZ);
142: CodeSource cs = new CodeSource(null, (Certificate[]) null);
143: CodeSource cs2 = new CodeSource(new URL("http://a.b.c"),
144: (Certificate[]) null);
145: ProtectionDomain pd1 = new ProtectionDomain(cs, null);
146: ProtectionDomain pd2 = new ProtectionDomain(cs2, pcZ, null,
147: new Principal[] { new FakePrincipal("qqq") });
148:
149: PolicyEntry pe1 = new PolicyEntry(cs, null, Arrays
150: .asList(new Permission[] { sp1 }));
151: PolicyEntry pe2 = new PolicyEntry(cs2, Arrays
152: .asList(new Principal[] { new UnresolvedPrincipal(
153: UnresolvedPrincipal.WILDCARD,
154: UnresolvedPrincipal.WILDCARD) }), Arrays
155: .asList(new Permission[] { sp2 }));
156: PolicyEntry pe3 = new PolicyEntry(cs, Arrays
157: .asList(new Principal[] { new UnresolvedPrincipal(
158: FakePrincipal.class.getName(), "qqq") }),
159: Arrays.asList(new Permission[] { sp3 }));
160: PolicyEntry pe4 = new PolicyEntry(cs2, Arrays
161: .asList(new Principal[] { new UnresolvedPrincipal(
162: FakePrincipal.class.getName(), "ttt") }),
163: Arrays.asList(new Permission[] { sp4 }));
164: PolicyEntry[] peArray = new PolicyEntry[] { pe1, pe2, pe3, pe4 };
165: DefaultPolicy policy = new DefaultPolicy(
166: new TestParser(peArray));
167:
168: assertTrue(policy.getPermissions(pd1).implies(sp1));
169: assertFalse(policy.getPermissions(pd1).implies(sp2));
170: assertFalse(policy.getPermissions(pd1).implies(sp3));
171: assertFalse(policy.getPermissions(pd1).implies(sp4));
172:
173: assertTrue(policy.getPermissions(pd2).implies(sp1));
174: assertTrue(policy.getPermissions(pd2).implies(sp2));
175: assertTrue(policy.getPermissions(pd2).implies(sp3));
176: assertFalse(policy.getPermissions(pd2).implies(sp4));
177: }
178: }
|