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

Merge branch 'maint-rel-1.6' into develop

Browse source
This commit is contained in:
j2blake 2014-03-25 15:44:59 -04:00
commit 09dd8da784
19 changed files with 276 additions and 229 deletions
Download patch file Download diff file Expand all files Collapse all files

17
webapp/test/edu/cornell/mannlib/vitro/webapp/auth/policy/SelfEditingPolicy_2_Test.java
View file

@ -4,11 +4,8 @@ package edu.cornell.mannlib.vitro.webapp.auth.policy;
import static edu.cornell.mannlib.vitro.webapp.auth.requestedAction.ifaces.RequestActionConstants.SOME_LITERAL;
import java.io.InputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.Level;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@ -19,7 +16,6 @@ import stubs.javax.servlet.ServletContextStub;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.impl.RDFDefaultErrorHandler;
import edu.cornell.mannlib.vitro.testing.AbstractTestClass;
import edu.cornell.mannlib.vitro.webapp.auth.identifier.ArrayIdentifierBundle;
@ -81,19 +77,6 @@ public class SelfEditingPolicy_2_Test extends AbstractTestClass {
@Before
public void setUp() throws Exception {
InputStream is = getClass().getResourceAsStream(
"./SelfEditingPolicy_2_Test.xml");
Assert.assertNotNull(is);
// suppress the warning messages from loading the model.
setLoggerLevel(RDFDefaultErrorHandler.class, Level.OFF);
// TODO This doesn't appear to be used for anything. Can it go away, along with the data file?
OntModel model = ModelFactory.createOntologyModel();
model.read(is, "");
Assert.assertNotNull(model);
Assert.assertTrue(model.size() > 0);
ServletContextStub ctx = new ServletContextStub();
PropertyRestrictionPolicyHelper.setBean(ctx,
PropertyRestrictionPolicyHelperStub

45
webapp/test/edu/cornell/mannlib/vitro/webapp/auth/policy/SelfEditingPolicy_2_Test.xml
View file

@ -1,45 +0,0 @@
<?xml version='1.0' encoding='ISO-8859-1'?>
<!-- $This file is distributed under the terms of the license in /doc/license.txt$ -->
<rdf:RDF
xmlns:owl ="http://www.w3.org/2002/07/owl#"
xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs ="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd ="http://www.w3.org/2001/XMLSchema#"
xmlns:vitro="http://vitro.mannlib.cornell.edu/ns/vitro/0.7#"
xmlns =""
>
<owl:Ontology rdf:about="">
<rdfs:comment>
An ontology with a property with a prohibited annotation for unit testing.
</rdfs:comment>
</owl:Ontology>
<owl:AnnotationProperty rdf:about="vitro:selfEditProhibitedAnnot"/>
<owl:ObjectProperty rdf:about="vitro:hasSuperPowers">
<vitro:selfEditProhibitedAnnot rdf:datatype="xsd:boolean">true</vitro:selfEditProhibitedAnnot>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="vitro:mayPrintMoney">
<vitro:selfEditProhibitedAnnot rdf:datatype="xsd:boolean">true</vitro:selfEditProhibitedAnnot>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="vitro:getsOutOfJailFree">
<vitro:selfEditProhibitedAnnot rdf:datatype="xsd:boolean">true</vitro:selfEditProhibitedAnnot>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="vitro:canDeleteModel">
<vitro:selfEditProhibitedAnnot rdf:datatype="xsd:boolean">true</vitro:selfEditProhibitedAnnot>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="vitro:felonies">
<vitro:selfEditProhibitedAnnot rdf:datatype="xsd:boolean">true</vitro:selfEditProhibitedAnnot>
</owl:DatatypeProperty>
</rdf:RDF>

103
webapp/test/edu/cornell/mannlib/vitro/webapp/dao/filtering/IndividualFilteringByStatementTest.java
View file

@ -2,7 +2,9 @@
package edu.cornell.mannlib.vitro.webapp.dao.filtering;
import static edu.cornell.mannlib.vitro.webapp.auth.requestedAction.ifaces.RequestActionConstants.SOME_URI;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.*;
import static org.junit.Assert.fail;
import java.util.ArrayList;
@ -82,12 +84,22 @@ public class IndividualFilteringByStatementTest extends AbstractTestClass {
private static final String URI_VISIBLE_OBJECT_ORDINARY = "object://visible_on_ordinary";
private static final String URI_MAYBE_OBJECT_ORDINARY = "object://maybe_on_ordinary";
private static final String FAUX_DOMAIN_VISIBLE = "faux://visibleDomain";
private static final String FAUX_RANGE_VISIBLE = "faux://visibleRange";
private static final String FAUX_DOMAIN_HIDDEN = "faux://hiddenDomain";
private static final String FAUX_RANGE_HIDDEN = "faux://hiddenRange";
private static final String URI_FAUX_VISIBLE_ORDINARY = "object://faux_visible_on_ordinary";
private static final String URI_FAUX_HIDDEN_ORDINARY = "object://faux_hidden_on_ordinary";
private IndividualStub indSpecial;
private IndividualStub indOrdinary;
private Individual filteredSpecial;
private Individual filteredOrdinary;
@Before
public void createIndividuals() {
IndividualStub indSpecial = new IndividualStub(URI_INDIVIDUAL_SPECIAL);
indSpecial = new IndividualStub(URI_INDIVIDUAL_SPECIAL);
indSpecial.addDataPropertyStatement(PROPERTY_DATA_HIDDEN,
VALUE_HIDDEN_DATA_SPECIAL);
@ -96,17 +108,17 @@ public class IndividualFilteringByStatementTest extends AbstractTestClass {
indSpecial.addDataPropertyStatement(PROPERTY_DATA_MAYBE,
VALUE_MAYBE_DATA_SPECIAL);
indSpecial.addObjectPropertyStatement(PROPERTY_OBJECT_HIDDEN,
indSpecial.addObjectPropertyStatement(property(PROPERTY_OBJECT_HIDDEN),
URI_HIDDEN_OBJECT_SPECIAL);
indSpecial.addObjectPropertyStatement(PROPERTY_OBJECT_VISIBLE,
URI_VISIBLE_OBJECT_SPECIAL);
indSpecial.addObjectPropertyStatement(PROPERTY_OBJECT_MAYBE,
indSpecial.addObjectPropertyStatement(
property(PROPERTY_OBJECT_VISIBLE), URI_VISIBLE_OBJECT_SPECIAL);
indSpecial.addObjectPropertyStatement(property(PROPERTY_OBJECT_MAYBE),
URI_MAYBE_OBJECT_SPECIAL);
filteredSpecial = new IndividualFiltering(indSpecial,
new IndividualBasedFilter());
IndividualStub indOrdinary = new IndividualStub("someOtherUri");
indOrdinary = new IndividualStub("someOtherUri");
indOrdinary.addDataPropertyStatement(PROPERTY_DATA_HIDDEN,
VALUE_HIDDEN_DATA_ORDINARY);
@ -115,17 +127,30 @@ public class IndividualFilteringByStatementTest extends AbstractTestClass {
indOrdinary.addDataPropertyStatement(PROPERTY_DATA_MAYBE,
VALUE_MAYBE_DATA_ORDINARY);
indOrdinary.addObjectPropertyStatement(PROPERTY_OBJECT_HIDDEN,
URI_HIDDEN_OBJECT_ORDINARY);
indOrdinary.addObjectPropertyStatement(PROPERTY_OBJECT_VISIBLE,
URI_VISIBLE_OBJECT_ORDINARY);
indOrdinary.addObjectPropertyStatement(PROPERTY_OBJECT_MAYBE,
indOrdinary.addObjectPropertyStatement(
property(PROPERTY_OBJECT_HIDDEN), URI_HIDDEN_OBJECT_ORDINARY);
indOrdinary.addObjectPropertyStatement(
property(PROPERTY_OBJECT_VISIBLE), URI_VISIBLE_OBJECT_ORDINARY);
indOrdinary.addObjectPropertyStatement(property(PROPERTY_OBJECT_MAYBE),
URI_MAYBE_OBJECT_ORDINARY);
filteredOrdinary = new IndividualFiltering(indOrdinary,
new IndividualBasedFilter());
}
private ObjectProperty property(String propertyUri) {
return property(propertyUri, SOME_URI, SOME_URI);
}
private ObjectProperty property(String propertyUri, String domainUri,
String rangeUri) {
ObjectProperty op = new ObjectProperty();
op.setURI(propertyUri);
op.setDomainVClassURI(domainUri);
op.setRangeVClassURI(rangeUri);
return op;
}
// ----------------------------------------------------------------------
// Tests on data properties
// ----------------------------------------------------------------------
@ -363,6 +388,41 @@ public class IndividualFilteringByStatementTest extends AbstractTestClass {
fail("onOrdinary_getPopulatedObjectPropertyList not implemented");
}
// ----------------------------------------------------------------------
// Tests on Faux object properties
// ----------------------------------------------------------------------
@Test
public void hiddenFauxWithVisibleBase() {
indOrdinary.addObjectPropertyStatement(
property(PROPERTY_OBJECT_VISIBLE, FAUX_DOMAIN_HIDDEN,
FAUX_RANGE_HIDDEN), URI_FAUX_HIDDEN_ORDINARY);
filteredOrdinary = new IndividualFiltering(indOrdinary,
new IndividualBasedFilter());
List<ObjectPropertyStatement> expected = opsList(filteredOrdinary,
ops(PROPERTY_OBJECT_VISIBLE, URI_VISIBLE_OBJECT_ORDINARY));
List<ObjectPropertyStatement> actual = filteredOrdinary
.getObjectPropertyStatements();
assertEquivalentOpsList("hidden faux is not visible", expected, actual);
}
@Test
public void visibleFauxWithHiddenBase() {
indOrdinary.addObjectPropertyStatement(
property(PROPERTY_OBJECT_HIDDEN, FAUX_DOMAIN_VISIBLE,
FAUX_RANGE_VISIBLE), URI_FAUX_VISIBLE_ORDINARY);
filteredOrdinary = new IndividualFiltering(indOrdinary,
new IndividualBasedFilter());
List<ObjectPropertyStatement> expected = opsList(filteredOrdinary,
ops(PROPERTY_OBJECT_VISIBLE, URI_VISIBLE_OBJECT_ORDINARY),
ops(PROPERTY_OBJECT_HIDDEN, URI_FAUX_VISIBLE_ORDINARY));
List<ObjectPropertyStatement> actual = filteredOrdinary
.getObjectPropertyStatements();
assertEquivalentOpsList("visible faux even if base is hidden",
expected, actual);
}
// ----------------------------------------------------------------------
// Helper methods
// ----------------------------------------------------------------------
@ -726,14 +786,33 @@ public class IndividualFilteringByStatementTest extends AbstractTestClass {
@Override
public Boolean fn(ObjectPropertyStatement ops) {
if (PROPERTY_OBJECT_VISIBLE.equals(ops.getPropertyURI())) {
return true;
if (isFauxHidden(ops)) {
return false;
} else {
return true;
}
}
if (PROPERTY_OBJECT_MAYBE.equals(ops.getPropertyURI())
&& URI_INDIVIDUAL_SPECIAL.equals(ops.getSubjectURI())) {
return true;
}
if (isFauxVisible(ops)) {
return true;
}
return false;
}
private boolean isFauxHidden(ObjectPropertyStatement ops) {
ObjectProperty prop = ops.getProperty();
return FAUX_DOMAIN_HIDDEN.equals(prop.getDomainVClassURI())
&& FAUX_RANGE_HIDDEN.equals(prop.getRangeVClassURI());
}
private boolean isFauxVisible(ObjectPropertyStatement ops) {
ObjectProperty prop = ops.getProperty();
return FAUX_DOMAIN_VISIBLE.equals(prop.getDomainVClassURI())
&& FAUX_RANGE_VISIBLE.equals(prop.getRangeVClassURI());
}
}
// ----------------------------------------------------------------------

82
webapp/test/stubs/edu/cornell/mannlib/vitro/webapp/beans/IndividualStub.java
View file

@ -12,6 +12,9 @@ import java.util.Set;
import org.json.JSONException;
import org.json.JSONObject;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.ResourceFactory;
import edu.cornell.mannlib.vitro.webapp.beans.BaseResourceBean.RoleLevel;
import edu.cornell.mannlib.vitro.webapp.beans.DataProperty;
import edu.cornell.mannlib.vitro.webapp.beans.DataPropertyStatement;
@ -21,6 +24,7 @@ import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatement;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectPropertyStatementImpl;
import edu.cornell.mannlib.vitro.webapp.beans.VClass;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
/**
* Mock the basic functions of Individual for unit tests.
@ -31,6 +35,8 @@ public class IndividualStub implements Individual {
// ----------------------------------------------------------------------
private final String uri;
private final String namespace;
private final String localName;
private final Set<DataPropertyStatement> dpsSet = new HashSet<DataPropertyStatement>();
private final Set<ObjectPropertyStatement> opsSet = new HashSet<ObjectPropertyStatement>();
@ -40,27 +46,25 @@ public class IndividualStub implements Individual {
public IndividualStub(String uri) {
this.uri = uri;
Resource r = ResourceFactory.createResource(uri);
this.namespace = r.getNameSpace();
this.localName = r.getLocalName();
}
public void addDataPropertyStatement(String predicateUri, String object) {
dpsSet.add(new DataPropertyStatementImpl(this.uri, predicateUri, object));
}
public void addObjectPropertyStatement(String predicateUri, String objectUri) {
opsSet.add(new ObjectPropertyStatementImpl(this.uri, predicateUri,
objectUri));
public void addObjectPropertyStatement(ObjectProperty property, String objectUri) {
ObjectPropertyStatementImpl ops = new ObjectPropertyStatementImpl();
ops.setSubject(this);
ops.setProperty(property);
ops.setObjectURI(objectUri);
opsSet.add(ops);
}
public void addPopulatedObjectPropertyStatement(String predicateUri,
String objectUri, Individual object) {
ObjectPropertyStatementImpl stmt = new ObjectPropertyStatementImpl(
this.uri, predicateUri, objectUri);
stmt.setObject(object);
opsSet.add(stmt);
}
public void addVclass(String namespace, String localname, String vClassName) {
vClasses.add(new VClass(namespace, localname, vClassName));
public void addVclass(String ns, String localname, String vClassName) {
vClasses.add(new VClass(ns, localname, vClassName));
}
// ----------------------------------------------------------------------
@ -72,6 +76,22 @@ public class IndividualStub implements Individual {
return uri;
}
@Override
public boolean isAnonymous() {
return (this.uri == null || VitroVocabulary.PSEUDO_BNODE_NS.equals(this
.getNamespace()));
}
@Override
public String getLocalName() {
return this.localName;
}
@Override
public String getNamespace() {
return this.namespace;
}
@Override
public void setName(String name) {
this.name = name;
@ -166,12 +186,6 @@ public class IndividualStub implements Individual {
// does nothing.
}
@Override
public String getLocalName() {
// Useless for now.
return "BOGUS Local Name";
}
@Override
public VClass getVClass() {
for (VClass vc : vClasses) {
@ -197,69 +211,57 @@ public class IndividualStub implements Individual {
// Un-implemented methods
// ----------------------------------------------------------------------
@Override
public boolean isAnonymous() {
throw new RuntimeException(
"ResourceBean.isAnonymous() not implemented.");
}
@Override
public void setURI(String URI) {
throw new RuntimeException("ResourceBean.setURI() not implemented.");
}
@Override
public String getNamespace() {
throw new RuntimeException(
"ResourceBean.getNamespace() not implemented.");
throw new RuntimeException("IndividualStub.setURI() not implemented.");
}
@Override
public void setNamespace(String namespace) {
throw new RuntimeException(
"ResourceBean.setNamespace() not implemented.");
"IndividualStub.setNamespace() not implemented.");
}
@Override
public void setLocalName(String localName) {
throw new RuntimeException(
"ResourceBean.setLocalName() not implemented.");
"IndividualStub.setLocalName() not implemented.");
}
@Override
public RoleLevel getHiddenFromDisplayBelowRoleLevel() {
throw new RuntimeException(
"ResourceBean.getHiddenFromDisplayBelowRoleLevel() not implemented.");
"IndividualStub.getHiddenFromDisplayBelowRoleLevel() not implemented.");
}
@Override
public void setHiddenFromDisplayBelowRoleLevel(RoleLevel eR) {
throw new RuntimeException(
"ResourceBean.setHiddenFromDisplayBelowRoleLevel() not implemented.");
"IndividualStub.setHiddenFromDisplayBelowRoleLevel() not implemented.");
}
@Override
public void setHiddenFromDisplayBelowRoleLevelUsingRoleUri(String roleUri) {
throw new RuntimeException(
"ResourceBean.setHiddenFromDisplayBelowRoleLevelUsingRoleUri() not implemented.");
"IndividualStub.setHiddenFromDisplayBelowRoleLevelUsingRoleUri() not implemented.");
}
@Override
public RoleLevel getProhibitedFromUpdateBelowRoleLevel() {
throw new RuntimeException(
"ResourceBean.getProhibitedFromUpdateBelowRoleLevel() not implemented.");
"IndividualStub.getProhibitedFromUpdateBelowRoleLevel() not implemented.");
}
@Override
public void setProhibitedFromUpdateBelowRoleLevel(RoleLevel eR) {
throw new RuntimeException(
"ResourceBean.setProhibitedFromUpdateBelowRoleLevel() not implemented.");
"IndividualStub.setProhibitedFromUpdateBelowRoleLevel() not implemented.");
}
@Override
public void setProhibitedFromUpdateBelowRoleLevelUsingRoleUri(String roleUri) {
throw new RuntimeException(
"ResourceBean.setProhibitedFromUpdateBelowRoleLevelUsingRoleUri() not implemented.");
"IndividualStub.setProhibitedFromUpdateBelowRoleLevelUsingRoleUri() not implemented.");
}
@Override