Skip to content

Commit

Permalink
start some unit tests for JcrPropertyStatementListener and FedoraType…
Browse files Browse the repository at this point in the history
…sUtils
  • Loading branch information
barmintor committed May 14, 2013
1 parent f47ab78 commit 92b5f6b
Show file tree
Hide file tree
Showing 5 changed files with 275 additions and 32 deletions.
Expand Up @@ -24,7 +24,7 @@ public class JcrPropertyStatementListener extends StatementListener {

private Problems problems;

private static final Logger logger = getLogger(JcrPropertyStatementListener.class);
private static final Logger LOGGER = getLogger(JcrPropertyStatementListener.class);

private final Node node;

Expand All @@ -39,13 +39,13 @@ public JcrPropertyStatementListener(final Node node) throws RepositoryException
*/
@Override
public void addedStatement( Statement s ) {
logger.trace(">> added statement " + s);
LOGGER.debug(">> added statement {}", s);

try {
final Resource subject = s.getSubject();

// if it's not about a node, ignore it.
if(!isFedoraGraphSubject.apply(subject)) {
if(!isFedoraGraphSubject(subject)) {
return;
}

Expand All @@ -70,13 +70,13 @@ public void addedStatement( Statement s ) {
*/
@Override
public void removedStatement( Statement s ) {
logger.trace(">> removed statement " + s);
LOGGER.trace(">> removed statement {}", s);

try {
final Resource subject = s.getSubject();

// if it's not about a node, we don't care.
if(!isFedoraGraphSubject.apply(subject)) {
if(!isFedoraGraphSubject(subject)) {
return;
}

Expand Down
10 changes: 3 additions & 7 deletions fcrepo-kernel/src/main/java/org/fcrepo/utils/JcrRdfTools.java
Expand Up @@ -84,7 +84,7 @@ public static Resource getGraphSubject(final Node node) throws RepositoryExcepti
*/
public static Node getNodeFromGraphSubject(final Session session, final Resource subject) throws RepositoryException {

if(!isFedoraGraphSubject.apply(subject)) {
if(!isFedoraGraphSubject(subject)) {
return null;
}

Expand All @@ -103,16 +103,12 @@ public static Node getNodeFromGraphSubject(final Session session, final Resource
/**
* Predicate for determining whether this {@link Node} is a Fedora object.
*/
public static Predicate<Resource> isFedoraGraphSubject = new Predicate<Resource>() {

@Override
public boolean apply(final Resource subject) {
public static boolean isFedoraGraphSubject(final Resource subject) {
checkArgument(subject != null, "null cannot be a Fedora object!");
assert(subject != null);

return subject.isURIResource() && subject.getURI().startsWith("info:fedora");
}
};
}

/**
* Get an RDF Model for a node that includes all its own JCR properties, as well as the properties of its
Expand Down
24 changes: 4 additions & 20 deletions fcrepo-kernel/src/test/java/org/fcrepo/FedoraResourceTest.java
@@ -1,48 +1,32 @@
package org.fcrepo;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.lang.reflect.Field;
import java.util.Calendar;
import java.util.Date;

import javax.jcr.AccessDeniedException;
import javax.jcr.InvalidItemStateException;
import javax.jcr.ItemExistsException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.ReferentialIntegrityException;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.nodetype.NodeType;
import javax.jcr.version.VersionException;

import org.fcrepo.utils.FedoraTypesUtils;
import org.fcrepo.utils.JcrPropertyStatementListener;
import org.fcrepo.utils.JcrRdfTools;
import org.fcrepo.utils.NamespaceTools;
import org.junit.Before;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.modeshape.common.collection.Problems;
import org.modeshape.jcr.api.JcrConstants;
import org.modeshape.jcr.api.NamespaceRegistry;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.api.mockito.PowerMockito;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;

@RunWith(PowerMockRunner.class)
// PowerMock needs to ignore some packages to prevent class-cast errors
Expand Down
108 changes: 108 additions & 0 deletions fcrepo-kernel/src/test/java/org/fcrepo/utils/FedoraTypesUtilsTest.java
@@ -0,0 +1,108 @@
package org.fcrepo.utils;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;

import java.io.InputStream;

import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.ValueFactory;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.NodeTypeManager;
import javax.jcr.nodetype.PropertyDefinition;

import org.junit.Test;
import org.modeshape.jcr.JcrValueFactory;
import org.modeshape.jcr.api.Namespaced;
import org.modeshape.jcr.value.binary.StrategyHint;

import com.google.common.base.Predicate;

public class FedoraTypesUtilsTest {

// unfortunately, we need to be able to cast to two interfaces to perform some tests
// this testing interface allows mocks to do that
static interface PropertyMock extends Property, Namespaced {};

@Test
public void testIsMultipleValuedProperty() throws RepositoryException {
Property mockYes = mock(Property.class);
when(mockYes.isMultiple()).thenReturn(true);
Property mockNo = mock(Property.class);
Predicate<Property> test = FedoraTypesUtils.isMultipleValuedProperty;
try {
test.apply(null);
fail("Null values should throw an IllegalArgumentException");
} catch (IllegalArgumentException e) {}
boolean actual = test.apply(mockYes);
assertEquals(true, actual);
actual = test.apply(mockNo);
assertEquals(false, actual);
}

@Test
public void testGetValueFactory() throws RepositoryException {
Node mockNode = mock(Node.class);
Session mockSession = mock(Session.class);
ValueFactory mockVF = mock(ValueFactory.class);
when(mockNode.getSession()).thenReturn(mockSession);
when(mockSession.getValueFactory()).thenReturn(mockVF);
ValueFactory actual = FedoraTypesUtils.getValueFactory.apply(mockNode);
assertEquals(mockVF, actual);
}

@Test
public void testGetPredicateForProperty() {
PropertyMock mockProp = mock(PropertyMock.class);
com.hp.hpl.jena.rdf.model.Property actual =
FedoraTypesUtils.getPredicateForProperty.apply(mockProp);
}

@Test
public void testGetBinary() throws RepositoryException {
Node mockNode = mock(Node.class);
Session mockSession = mock(Session.class);
ValueFactory mockVF = mock(ValueFactory.class);
when(mockNode.getSession()).thenReturn(mockSession);
when(mockSession.getValueFactory()).thenReturn(mockVF);
InputStream mockInput = mock(InputStream.class);
FedoraTypesUtils.getBinary(mockNode, mockInput);
verify(mockVF).createBinary(mockInput);
// try it with hints
JcrValueFactory mockJVF = mock(JcrValueFactory.class);
when(mockSession.getValueFactory()).thenReturn(mockJVF);
StrategyHint mockHint = mock(StrategyHint.class);
FedoraTypesUtils.getBinary(mockNode, mockInput, mockHint);
verify(mockJVF).createBinary(mockInput, mockHint);
}

@Test
public void testGetDefinitionForPropertyName() throws RepositoryException {
Node mockNode = mock(Node.class);
String mockPropertyName = "mock:property";
Session mockSession = mock(Session.class);
when(mockNode.getSession()).thenReturn(mockSession);
Workspace mockWS = mock(Workspace.class);
when(mockSession.getWorkspace()).thenReturn(mockWS);
NodeTypeManager mockNTM = mock(NodeTypeManager.class);
when(mockWS.getNodeTypeManager()).thenReturn(mockNTM);
NodeType mockType = mock(NodeType.class);
when(mockNTM.getNodeType(anyString())).thenReturn(mockType);
PropertyDefinition mockPD = mock(PropertyDefinition.class);
when(mockPD.getName()).thenReturn(mockPropertyName);
PropertyDefinition[] PDs = new PropertyDefinition[]{mockPD};
when(mockType.getPropertyDefinitions()).thenReturn(PDs);
PropertyDefinition actual =
FedoraTypesUtils.getDefinitionForPropertyName(mockNode, mockPropertyName);
assertEquals(mockPD, actual);
actual =
FedoraTypesUtils.getDefinitionForPropertyName(mockNode, mockPropertyName + ":fail");
assertEquals(null, actual);

}
}
@@ -0,0 +1,155 @@
package org.fcrepo.utils;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.*;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.verifyStatic;

import javax.jcr.Node;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;


@RunWith(PowerMockRunner.class)
@PrepareForTest({JcrRdfTools.class, NodePropertiesTools.class})
public class JcrPropertyStatementListenerTest {

private JcrPropertyStatementListener testObj;

private Node mockNode;

private Session mockSession;

private Statement mockStatement;

private Resource mockSubject;

private Property mockPredicate;

@Before
public void setUp() throws RepositoryException {
mockNode = mock(Node.class);
mockSession = mock(Session.class);
when(mockNode.getSession()).thenReturn(mockSession);
testObj = new JcrPropertyStatementListener(mockNode);
mockSubject = mock(Resource.class);
mockStatement = mock(Statement.class);
when(mockStatement.getSubject()).thenReturn(mockSubject);
mockPredicate = mock(Property.class);
when(mockStatement.getPredicate()).thenReturn(mockPredicate);
}

@Test
public void testAddedIrrelevantStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(false);
testObj.addedStatement(mockStatement);
verifyStatic(never());
JcrRdfTools.getNodeFromGraphSubject(any(Session.class), any(Resource.class));
// this was ignored, but not a problem
assertEquals(0, testObj.getProblems().size());
}

@Test
public void testAddedProhibitedStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(true);
Node mockSubjectNode = mock(Node.class);
when(JcrRdfTools.getNodeFromGraphSubject(mockSession, mockSubject))
.thenReturn(mockSubjectNode);

String mockPropertyName = "jcr:property";
when(JcrRdfTools.getPropertyNameFromPredicate(mockSubjectNode, mockPredicate))
.thenReturn(mockPropertyName);

testObj.addedStatement(mockStatement);
assertEquals(1, testObj.getProblems().size());
}

@Test
public void testAddedStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(true);
Node mockSubjectNode = mock(Node.class);
when(JcrRdfTools.getNodeFromGraphSubject(mockSession, mockSubject))
.thenReturn(mockSubjectNode);

String mockPropertyName = "mock:property";
when(JcrRdfTools.getPropertyNameFromPredicate(mockSubjectNode, mockPredicate))
.thenReturn(mockPropertyName);

mockStatic(NodePropertiesTools.class);
when(NodePropertiesTools.getPropertyType(mockSubjectNode, mockPropertyName))
.thenReturn(PropertyType.STRING);
testObj.addedStatement(mockStatement);
assertEquals(0, testObj.getProblems().size());
}

@Test
public void testRemovedStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(true);
Node mockSubjectNode = mock(Node.class);
when(JcrRdfTools.getNodeFromGraphSubject(mockSession, mockSubject))
.thenReturn(mockSubjectNode);

String mockPropertyName = "mock:property";
when(JcrRdfTools.getPropertyNameFromPredicate(mockSubjectNode, mockPredicate))
.thenReturn(mockPropertyName);

when(mockSubjectNode.hasProperty(mockPropertyName))
.thenReturn(true);

mockStatic(NodePropertiesTools.class);
when(NodePropertiesTools.getPropertyType(mockSubjectNode, mockPropertyName))
.thenReturn(PropertyType.STRING);
testObj.removedStatement(mockStatement);
assertEquals(0, testObj.getProblems().size());
}

@Test
public void testRemovedProhibitedStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(true);
Node mockSubjectNode = mock(Node.class);
when(JcrRdfTools.getNodeFromGraphSubject(mockSession, mockSubject))
.thenReturn(mockSubjectNode);

String mockPropertyName = "jcr:property";
when(JcrRdfTools.getPropertyNameFromPredicate(mockSubjectNode, mockPredicate))
.thenReturn(mockPropertyName);

when(mockSubjectNode.hasProperty(mockPropertyName))
.thenReturn(true);

mockStatic(NodePropertiesTools.class);
when(NodePropertiesTools.getPropertyType(mockSubjectNode, mockPropertyName))
.thenReturn(PropertyType.STRING);
testObj.removedStatement(mockStatement);
assertEquals(1, testObj.getProblems().size());
}

@Test
public void testRemovedIrrelevantStatement() throws RepositoryException {
mockStatic(JcrRdfTools.class);
when(JcrRdfTools.isFedoraGraphSubject(mockSubject)).thenReturn(false);
testObj.removedStatement(mockStatement);
verifyStatic(never());
JcrRdfTools.getNodeFromGraphSubject(any(Session.class), any(Resource.class));
// this was ignored, but not a problem
assertEquals(0, testObj.getProblems().size());
}

}

0 comments on commit 92b5f6b

Please sign in to comment.