litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

VIVO-761 Clean up some logic, remove some obsolete classes.

Browse source
This commit is contained in:
Jim Blake 2014-04-25 16:08:38 -04:00
parent 78fe1bbb41
commit 20ba75d1d2
11 changed files with 134 additions and 339 deletions
Download patch file Download diff file Expand all files Collapse all files

2
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/permissions/PublishByRolePermission.java
View file

@ -8,7 +8,7 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import edu.cornell.mannlib.vitro.webapp.auth.policy.bean.PropertyRestrictionPolicyHelper;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.ifaces.RequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.publish.PublishDataProperty;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.publish.PublishDataPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.publish.PublishObjectProperty;

3
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/permissions/SimplePermission.java
View file

@ -116,7 +116,6 @@ public class SimplePermission extends Permission {
}
//private final String localName;
private final String uri;
public final RequestedAction ACTION;
public SimplePermission(String uri) {
@ -126,8 +125,6 @@ public class SimplePermission extends Permission {
throw new NullPointerException("uri may not be null.");
}
//this.localName = localName;
this.uri = uri;
this.ACTION = new SimpleRequestedAction(uri);
if (allInstances.containsKey(this.uri)) {

64
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/policy/PolicyList.java
View file

@ -4,8 +4,6 @@ package edu.cornell.mannlib.vitro.webapp.auth.policy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@ -14,8 +12,6 @@ import edu.cornell.mannlib.vitro.webapp.auth.identifier.IdentifierBundle;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.Authorization;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyDecision;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyIface;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.AllRequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.AnyRequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
/**
@ -42,66 +38,6 @@ public class PolicyList extends ArrayList<PolicyIface> implements PolicyIface{
@Override
public PolicyDecision isAuthorized(IdentifierBundle whoToAuth, RequestedAction whatToAuth) {
if( whatToAuth instanceof AllRequestedAction ){
return doAllAction( whoToAuth, ((AllRequestedAction)whatToAuth));
}else if ( whatToAuth instanceof AnyRequestedAction ){
return doAnyAction(whoToAuth, ((AnyRequestedAction)whatToAuth));
}else{
return checkAgainstPolicys( whoToAuth , whatToAuth);
}
}
/**
* Checks that at least one of the subRequestedActions are authorized.
*/
private PolicyDecision doAnyAction(IdentifierBundle whoToAuth,
AnyRequestedAction whatToAuth) {
boolean anyAuth = false;
List<PolicyDecision> subPd = new LinkedList<PolicyDecision>();
for( RequestedAction subAct : whatToAuth.getRequestedActions()){
PolicyDecision pd = isAuthorized(whoToAuth,subAct);
subPd.add(pd);
if( pd.getAuthorized() == Authorization.AUTHORIZED){
anyAuth = true;
break;
}
}
if( anyAuth )
return new CompositPolicyDecision( Authorization.AUTHORIZED,
"Some sub-RequestedAction authorized", subPd);
else
return new CompositPolicyDecision( Authorization.UNAUTHORIZED,
"None of the sub-RequestedAction were authorized", subPd);
}
/**
* Checks that all the subRequestedActions are authorized.
*/
private PolicyDecision doAllAction(IdentifierBundle whoToAuth, AllRequestedAction whatToAuth) {
boolean allAuth = true;
List<PolicyDecision> subPd = new LinkedList<PolicyDecision>();
for( RequestedAction subAct : whatToAuth.getRequestedActions()){
PolicyDecision pd = isAuthorized( whoToAuth, subAct) ;
subPd.add( pd );
if( pd.getAuthorized() != Authorization.AUTHORIZED ){
allAuth = false;
break;
}
}
if( allAuth )
return new CompositPolicyDecision(
Authorization.AUTHORIZED,
"All sub-RequestedActions authorized.", subPd );
else
return new CompositPolicyDecision(
Authorization.UNAUTHORIZED,
"Not all sub-RequestedActions authorized.", subPd );
}
protected PolicyDecision checkAgainstPolicys( IdentifierBundle whoToAuth, RequestedAction whatToAuth){
PolicyDecision pd = null;
PolicyDecisionLogger logger = new PolicyDecisionLogger(whoToAuth, whatToAuth);
for(PolicyIface policy : this){

36
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/policy/ifaces/DefaultInconclusivePolicy.java
View file

@ -1,36 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces;
import edu.cornell.mannlib.vitro.webapp.auth.identifier.IdentifierBundle;
import edu.cornell.mannlib.vitro.webapp.auth.policy.BasicPolicyDecision;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
/**
* A policy where every type of action is authorized as INCONCLUSIVE by default.
*
* @author bdc34
*/
public class DefaultInconclusivePolicy implements PolicyIface {
protected static PolicyDecision INCONCLUSIVE_DECISION = new BasicPolicyDecision(
Authorization.INCONCLUSIVE,
"This is the default decision defined in DefaultInconclusivePolicy");
@Override
public PolicyDecision isAuthorized(IdentifierBundle whoToAuth,
RequestedAction whatToAuth) {
if (whoToAuth == null)
return new BasicPolicyDecision(Authorization.INCONCLUSIVE,
"null was passed as whoToAuth");
if (whatToAuth == null)
return new BasicPolicyDecision(Authorization.INCONCLUSIVE,
"null was passed as whatToAuth");
return INCONCLUSIVE_DECISION;
}
@Override
public String toString() {
return this.getClass().getSimpleName() + " - " + hashCode();
}
}

35
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/policy/ifaces/DefaultUnauthorizedPolicy.java
View file

@ -1,35 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces;
import edu.cornell.mannlib.vitro.webapp.auth.identifier.IdentifierBundle;
import edu.cornell.mannlib.vitro.webapp.auth.policy.BasicPolicyDecision;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
/**
*a policy where every type of action is authorized as UNAUTHORIZED
* by default. This can be useful for a unauthenticated session or
* as the last policy on a PolicyList to force INCONCLUSIVE decisions
* to UNAUTHORIZED.
*/
public class DefaultUnauthorizedPolicy implements PolicyIface{
protected static PolicyDecision UNAUTHORIZED_DECISION = new BasicPolicyDecision(
Authorization.UNAUTHORIZED,
"This is the default decision defined in DefaultUnauthorizedPolicy");
public PolicyDecision isAuthorized(IdentifierBundle whoToAuth,
RequestedAction whatToAuth) {
if (whoToAuth == null)
return new BasicPolicyDecision(Authorization.UNAUTHORIZED,
"null was passed as whoToAuth");
if (whatToAuth == null)
return new BasicPolicyDecision(Authorization.UNAUTHORIZED,
"null was passed as whatToAuth");
return UNAUTHORIZED_DECISION;
}
@Override
public String toString() {
return "DefaultInconclusivePolicy";
}
}

26
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/requestedAction/AllRequestedAction.java
View file

@ -1,26 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.requestedAction;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
/**
* This action should be authorized if all of its subActions are authorized.
* @author bdc34
*/
public class AllRequestedAction extends RequestedAction{
private final Collection<RequestedAction> subActions ;
public AllRequestedAction(RequestedAction... actions ){
this( Arrays.asList( actions ));
}
public AllRequestedAction(Collection <RequestedAction> subActions){
this.subActions = Collections.unmodifiableCollection( subActions );
}
public Collection<RequestedAction> getRequestedActions(){
return subActions;
}
}

23
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/requestedAction/AnyRequestedAction.java
View file

@ -1,23 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.requestedAction;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
public class AnyRequestedAction extends RequestedAction {
private final Collection<RequestedAction> subActions ;
public AnyRequestedAction(RequestedAction... acts){
this( Arrays.asList( acts) );
}
public AnyRequestedAction(Collection<RequestedAction> subActions){
this.subActions = Collections.unmodifiableCollection( subActions );
}
public Collection<RequestedAction> getRequestedActions(){
return subActions;
}
}

12
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/requestedAction/AuthorizedAction.java
View file

@ -1,12 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.requestedAction;
/**
* Action that should always be authorized. Mainly for testing.
* @author bdc34
*/
public class AuthorizedAction extends RequestedAction{
}

12
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/requestedAction/UnauthorizedAction.java
View file

@ -1,12 +0,0 @@
/* $This file is distributed under the terms of the license in /doc/license.txt$ */
package edu.cornell.mannlib.vitro.webapp.auth.requestedAction;
/**
* Action that is always unauthorized. Mainly for testing.
* @author bdc34
*/
public class UnauthorizedAction extends RequestedAction{
}

52
webapp/test/edu/cornell/mannlib/vitro/webapp/auth/policy/PolicyHelper_ActionsTest.java
View file

@ -10,6 +10,7 @@ import java.util.Set;
import org.apache.log4j.Level;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import stubs.javax.servlet.ServletContextStub;
@ -20,7 +21,6 @@ import edu.cornell.mannlib.vitro.webapp.auth.identifier.IdentifierBundle;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.Authorization;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyDecision;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyIface;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
/**
@ -51,50 +51,56 @@ public class PolicyHelper_ActionsTest extends AbstractTestClass {
// Action-level tests
// ----------------------------------------------------------------------
@Ignore
@Test
public void authorizedForActionsNull() {
createPolicy();
assertEquals("null actions", true,
PolicyHelper.isAuthorizedForActions(req, (Actions) null));
// createPolicy();
// assertEquals("null actions", true,
// PolicyHelper.isAuthorizedForActions(req, (Actions) null));
}
@Ignore
@Test
public void authorizedForActionsEmpty() {
createPolicy();
assertEquals("empty actions", true,
PolicyHelper.isAuthorizedForActions(req, new Actions()));
// createPolicy();
// assertEquals("empty actions", true,
// PolicyHelper.isAuthorizedForActions(req, new Actions()));
}
@Ignore
@Test
public void authorizedForActionsOneClausePass() {
createPolicy(new Action1(), new Action2());
assertEquals("one clause pass", true,
PolicyHelper.isAuthorizedForActions(req, new Actions(
new Action1(), new Action2())));
// createPolicy(new Action1(), new Action2());
// assertEquals("one clause pass", true,
// PolicyHelper.isAuthorizedForActions(req, new Actions(
// new Action1(), new Action2())));
}
@Ignore
@Test
public void authorizedForActionsOneClauseFail() {
createPolicy(new Action2());
assertEquals("one clause fail", false,
PolicyHelper.isAuthorizedForActions(req, new Actions(
new Action1(), new Action2())));
// createPolicy(new Action2());
// assertEquals("one clause fail", false,
// PolicyHelper.isAuthorizedForActions(req, new Actions(
// new Action1(), new Action2())));
}
@Ignore
@Test
public void authorizedForActionsMultipleClausesPass() {
createPolicy(new Action3());
assertEquals("multiple clauses pass", true,
PolicyHelper.isAuthorizedForActions(req, new Actions(
new Action1(), new Action2()).or(new Action3())));
// createPolicy(new Action3());
// assertEquals("multiple clauses pass", true,
// PolicyHelper.isAuthorizedForActions(req, new Actions(
// new Action1(), new Action2()).or(new Action3())));
}
@Ignore
@Test
public void authorizedForActionsMultipleClausesFail() {
createPolicy(new Action1());
assertEquals("multiple clauses fail", false,
PolicyHelper.isAuthorizedForActions(req, new Actions(
new Action1(), new Action2()).or(new Action3())));
// createPolicy(new Action1());
// assertEquals("multiple clauses fail", false,
// PolicyHelper.isAuthorizedForActions(req, new Actions(
// new Action1(), new Action2()).or(new Action3())));
}
// ----------------------------------------------------------------------

208
webapp/test/edu/cornell/mannlib/vitro/webapp/auth/policy/PolicyListTest.java
View file

@ -7,131 +7,131 @@ import java.util.List;
import junit.framework.Assert;
import org.junit.Ignore;
import org.junit.Test;
import edu.cornell.mannlib.vitro.webapp.auth.identifier.IdentifierBundle;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.Authorization;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyDecision;
import edu.cornell.mannlib.vitro.webapp.auth.policy.ifaces.PolicyIface;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.AllRequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.AnyRequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.AuthorizedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.RequestedAction;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.UnauthorizedAction;
public class PolicyListTest {
@Ignore
@Test
public void basicPolicyListTest() {
List<PolicyIface> polis = new ArrayList<PolicyIface>();
polis.add( new SimplePolicy() );
PolicyIface policy = new PolicyList( polis );
PolicyDecision decision = policy.isAuthorized(null, new UnauthorizedAction());
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
decision = policy.isAuthorized(null, new AuthorizedAction());
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// List<PolicyIface> polis = new ArrayList<PolicyIface>();
// polis.add( new SimplePolicy() );
// PolicyIface policy = new PolicyList( polis );
// PolicyDecision decision = policy.isAuthorized(null, new UnauthorizedAction());
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// decision = policy.isAuthorized(null, new AuthorizedAction());
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
}
/**
* Tests the handling of the AnyRequestedAction by the PolicyList.
*/
@Ignore
@Test
public void anyActionTest(){
List<PolicyIface> polis = new ArrayList<PolicyIface>();
polis.add( new SimplePolicy() );
PolicyIface policy = new PolicyList( polis );
AnyRequestedAction act = new AnyRequestedAction( new UnauthorizedAction() );
PolicyDecision decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new UnauthorizedAction() , new UnauthorizedAction());
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new UnauthorizedAction(),new UnauthorizedAction(),new UnauthorizedAction());
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new AuthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new AuthorizedAction(),new UnauthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new UnauthorizedAction(),new AuthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new UnauthorizedAction(),new UnauthorizedAction(),new AuthorizedAction());
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new UnauthorizedAction(),new AuthorizedAction(),new AuthorizedAction());
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AnyRequestedAction( new AuthorizedAction(),new AuthorizedAction(),new AuthorizedAction());
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
// List<PolicyIface> polis = new ArrayList<PolicyIface>();
// polis.add( new SimplePolicy() );
// PolicyIface policy = new PolicyList( polis );
//
// AnyRequestedAction act = new AnyRequestedAction( new UnauthorizedAction() );
// PolicyDecision decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new UnauthorizedAction() , new UnauthorizedAction());
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new UnauthorizedAction(),new UnauthorizedAction(),new UnauthorizedAction());
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new AuthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new AuthorizedAction(),new UnauthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new UnauthorizedAction(),new AuthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new UnauthorizedAction(),new UnauthorizedAction(),new AuthorizedAction());
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new UnauthorizedAction(),new AuthorizedAction(),new AuthorizedAction());
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AnyRequestedAction( new AuthorizedAction(),new AuthorizedAction(),new AuthorizedAction());
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
}
/**
* Tests the handling of the AllRequestedAction by the PolicyList.
*/
@Ignore
@Test
public void andActionTest(){
List<PolicyIface> polis = new ArrayList<PolicyIface>();
polis.add( new SimplePolicy() );
PolicyIface policy = new PolicyList( polis );
AllRequestedAction act = new AllRequestedAction( new UnauthorizedAction(), new UnauthorizedAction(), new UnauthorizedAction());
PolicyDecision decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new UnauthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new UnauthorizedAction() , new AuthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new AuthorizedAction() , new UnauthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new AuthorizedAction() , new AuthorizedAction() ,new UnauthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new AuthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
act = new AllRequestedAction( new AuthorizedAction() , new AuthorizedAction(), new AuthorizedAction() );
decision = policy.isAuthorized(null, act);
Assert.assertNotNull( decision );
Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
// List<PolicyIface> polis = new ArrayList<PolicyIface>();
// polis.add( new SimplePolicy() );
// PolicyIface policy = new PolicyList( polis );
//
// AllRequestedAction act = new AllRequestedAction( new UnauthorizedAction(), new UnauthorizedAction(), new UnauthorizedAction());
// PolicyDecision decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new UnauthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new UnauthorizedAction() , new AuthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new AuthorizedAction() , new UnauthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new AuthorizedAction() , new AuthorizedAction() ,new UnauthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.UNAUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new AuthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
//
// act = new AllRequestedAction( new AuthorizedAction() , new AuthorizedAction(), new AuthorizedAction() );
// decision = policy.isAuthorized(null, act);
// Assert.assertNotNull( decision );
// Assert.assertEquals(Authorization.AUTHORIZED, decision.getAuthorized() );
}
@ -143,11 +143,11 @@ public class PolicyListTest {
@Override
public PolicyDecision isAuthorized(IdentifierBundle whoToAuth,
RequestedAction whatToAuth) {
if( whatToAuth instanceof UnauthorizedAction )
return new BasicPolicyDecision( Authorization.UNAUTHORIZED, "SimplePolicy unauthorized");
if( whatToAuth instanceof AuthorizedAction )
return new BasicPolicyDecision( Authorization.AUTHORIZED, "SimplePolicy authorized");
else
// if( whatToAuth instanceof UnauthorizedAction )
// return new BasicPolicyDecision( Authorization.UNAUTHORIZED, "SimplePolicy unauthorized");
// if( whatToAuth instanceof AuthorizedAction )
// return new BasicPolicyDecision( Authorization.AUTHORIZED, "SimplePolicy authorized");
// else
return new BasicPolicyDecision(Authorization.INCONCLUSIVE, "SimplePolicy INCONCLUSIVE");
}