Skip to content

Commit

Permalink
unit testing hotspots, and refactoring the default rdf generators
Browse files Browse the repository at this point in the history
  • Loading branch information
barmintor committed May 13, 2013
1 parent c8630ee commit f47ab78
Show file tree
Hide file tree
Showing 8 changed files with 275 additions and 66 deletions.
@@ -1,60 +1,31 @@

package org.fcrepo.generator.rdf;

import static com.google.common.collect.ImmutableList.copyOf;
import static com.google.common.collect.Iterables.concat;
import static com.google.common.collect.Lists.transform;
import static org.slf4j.LoggerFactory.getLogger;

import java.util.List;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.ws.rs.core.UriBuilderException;
import javax.ws.rs.core.UriInfo;

import org.fcrepo.Datastream;
import org.slf4j.Logger;
import com.google.common.base.Function;

public class DefaultDatastreamGenerator implements TripleSource<Datastream> {

private static final PropertiesGenerator propertiesGenerator =
new PropertiesGenerator();

private static final NodeTypesGenerator nodeTypesGenerator =
new NodeTypesGenerator();

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

@Override
public List<Triple> getTriples(final Datastream ds,
final UriInfo... uriInfos) throws RepositoryException {
final UriInfo uriInfo = uriInfos[0];
final Node node = ds.getNode();
logger.debug("Generating triples for object: " + ds.getDsId());
LOGGER.debug("Generating triples for object: " + ds.getDsId());
// now we alter the subjects of these triples to be true
// (and dereferenceable) URIs, based on our knowledge that these are
// Fedora datastreams
return transform(copyOf(concat(propertiesGenerator.getTriples(node,
uriInfo), nodeTypesGenerator.getTriples(node))),
new Function<Triple, Triple>() {

@Override
public Triple apply(final Triple t) {
if (t == null) {
return null;
}
try {
return new Triple(uriInfo.getBaseUriBuilder().path(
"rest").path(node.getPath())
.build().toString(), t.predicate, t.object);
} catch (UriBuilderException | RepositoryException e) {
throw new IllegalStateException(e);
}
}
});
return DefaultNodeGenerator.getTriples(node, uriInfos);

}
}
@@ -1,10 +1,6 @@

package org.fcrepo.generator.rdf;

import static com.google.common.collect.ImmutableList.copyOf;
import static com.google.common.collect.Iterables.concat;
import static com.google.common.collect.Lists.transform;

import java.util.List;

import javax.jcr.Node;
Expand All @@ -15,43 +11,21 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.Function;

public class DefaultFedoraObjectGenerator implements TripleSource<FedoraObject> {

final private static PropertiesGenerator propertiesGenerator =
new PropertiesGenerator();

final private static NodeTypesGenerator nodeTypesGenerator =
new NodeTypesGenerator();

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

@Override
public List<org.fcrepo.generator.rdf.TripleSource.Triple> getTriples(
final FedoraObject obj, final UriInfo... uriInfos)
throws RepositoryException {
final UriInfo uriInfo = uriInfos[0];
final Node node = obj.getNode();
logger.debug("Generating triples for object: " + obj.getName());
LOGGER.debug("Generating triples for object: " + obj.getName());
// now we alter the subjects of these triples to be true
// (and dereferenceable) URIs, based on our knowledge that these are
// Fedora objects
return transform(copyOf(concat(propertiesGenerator.getTriples(node,
uriInfo), nodeTypesGenerator.getTriples(node))),
new Function<Triple, Triple>() {

@Override
public Triple apply(final Triple t) {
if (t == null) {
return null;
}
return new Triple(uriInfo.getBaseUriBuilder().path("rest").path(
t.subject).build().toString(), t.predicate,
t.object);
}
});
return DefaultNodeGenerator.getTriples(node, uriInfos);

}
}
@@ -0,0 +1,58 @@

package org.fcrepo.generator.rdf;

import static com.google.common.collect.ImmutableList.copyOf;
import static com.google.common.collect.Iterables.concat;
import static com.google.common.collect.Lists.transform;
import static org.slf4j.LoggerFactory.getLogger;
import static org.fcrepo.generator.rdf.TripleSource.Triple;

import java.util.List;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.ws.rs.core.UriBuilderException;
import javax.ws.rs.core.UriInfo;

import org.slf4j.Logger;
import com.google.common.base.Function;

public abstract class DefaultNodeGenerator {

private static final PropertiesGenerator propertiesGenerator =
new PropertiesGenerator();

private static final NodeTypesGenerator nodeTypesGenerator =
new NodeTypesGenerator();

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

public static List<TripleSource.Triple> getTriples(final Node node,
final UriInfo... uriInfos) throws RepositoryException {
final UriInfo uriInfo = uriInfos[0];
logger.debug("Generating triples for object: {}" + node.getPath());
// now we alter the subjects of these triples to be true
// (and dereferenceable) URIs, based on our knowledge that these are
// Fedora datastreams
return transform(copyOf(concat(propertiesGenerator.getTriples(node,
uriInfo), nodeTypesGenerator.getTriples(node))),
new Function<Triple, Triple>() {

@Override
public Triple apply(final Triple t) {
if (t == null) {
return null;
}
try {
return new Triple(uriInfo.getBaseUriBuilder().path(
"rest").path(node.getPath())
.build().toString(), t.predicate, t.object);
} catch (UriBuilderException | RepositoryException e) {
throw new IllegalStateException(e);
}
}
});

}
}
@@ -0,0 +1,47 @@
package org.fcrepo.generator.rdf;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.verifyStatic;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.ws.rs.core.UriInfo;

import org.fcrepo.Datastream;
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;

@RunWith(PowerMockRunner.class)
@PrepareForTest({DefaultNodeGenerator.class})
public class DefaultDatastreamGeneratorTest {

private DefaultDatastreamGenerator testObj;

@Before
public void setUp() {
testObj = new DefaultDatastreamGenerator();
}

@Test
public void testGetTriples() throws RepositoryException {
String path = "/testing/fake/object";
UriInfo mockUris = mock(UriInfo.class);
Node mockNode = mock(Node.class);
when(mockNode.getPath()).thenReturn(path);
Datastream mockObj = mock(Datastream.class);
when(mockObj.getNode()).thenReturn(mockNode);
mockStatic(DefaultNodeGenerator.class);
when(DefaultNodeGenerator.getTriples(mockNode, mockUris))
.thenReturn(null);
testObj.getTriples(mockObj, mockUris);
verify(mockObj).getNode();
verifyStatic();
DefaultNodeGenerator.getTriples(mockNode, mockUris);
}
}
@@ -0,0 +1,47 @@
package org.fcrepo.generator.rdf;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.verifyStatic;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.ws.rs.core.UriInfo;

import org.fcrepo.FedoraObject;
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;

@RunWith(PowerMockRunner.class)
@PrepareForTest({DefaultNodeGenerator.class})
public class DefaultFedoraObjectGeneratorTest {

private DefaultFedoraObjectGenerator testObj;

@Before
public void setUp() {
testObj = new DefaultFedoraObjectGenerator();
}

@Test
public void testGetTriples() throws RepositoryException {
String path = "/testing/fake/object";
UriInfo mockUris = mock(UriInfo.class);
Node mockNode = mock(Node.class);
when(mockNode.getPath()).thenReturn(path);
FedoraObject mockObj = mock(FedoraObject.class);
when(mockObj.getNode()).thenReturn(mockNode);
mockStatic(DefaultNodeGenerator.class);
when(DefaultNodeGenerator.getTriples(mockNode, mockUris))
.thenReturn(null);
testObj.getTriples(mockObj, mockUris);
verify(mockObj).getNode();
verifyStatic();
DefaultNodeGenerator.getTriples(mockNode, mockUris);
}
}
@@ -0,0 +1,54 @@
package org.fcrepo.generator.rdf;

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

import java.net.URI;
import java.util.List;

import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.RepositoryException;
import javax.jcr.nodetype.NodeType;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;

import org.fcrepo.Datastream;
import org.fcrepo.generator.rdf.TripleSource.Triple;
import org.junit.Before;
import org.junit.Test;

public class DefaultNodeGeneratorTest {

@Test
public void testGetTriples() throws RepositoryException {
String path = "/testing/fake/object";
UriInfo mockUris = mock(UriInfo.class);
UriBuilder mockBuilder = mock(UriBuilder.class);
when(mockBuilder.path(anyString())).thenReturn(mockBuilder);
URI mockUri = URI.create("info:fedora/mock/test/uri");
when(mockBuilder.build()).thenReturn(mockUri);
when(mockUris.getBaseUriBuilder()).thenReturn(mockBuilder);
Node mockNode = mock(Node.class);
when(mockNode.getPath()).thenReturn(path);
Property mockProp = mock(Property.class);
when(mockProp.getParent()).thenReturn(mockNode);
when(mockProp.getString()).thenReturn("mockValue");
PropertyIterator mockProps = mock(PropertyIterator.class);
when(mockNode.getProperties()).thenReturn(mockProps);
NodeType mockType = mock(NodeType.class);
when(mockType.getName()).thenReturn("mock:nodeType");
when(mockNode.getPrimaryNodeType()).thenReturn(mockType);
NodeType mockMixin = mock(NodeType.class);
when(mockMixin.getName()).thenReturn("mock:mixinType");
NodeType[] mockMixins = new NodeType[]{mockMixin};
when(mockNode.getMixinNodeTypes()).thenReturn(mockMixins);
List<Triple> actual = DefaultNodeGenerator.getTriples(mockNode, mockUris);
assertTrue(actual.size() > 0);
for (Triple triple: actual) {
assertEquals(mockUri.toString(), triple.subject);
}
}
}
Expand Up @@ -8,7 +8,6 @@
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;


import java.io.IOException;
import java.util.HashMap;

Expand All @@ -26,15 +25,11 @@
import org.fcrepo.services.RepositoryService;
import org.fcrepo.session.SessionFactory;
import org.fcrepo.test.util.TestHelpers;
import org.fcrepo.utils.JcrRdfTools;
import org.fcrepo.utils.NamespaceTools;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.modeshape.jcr.api.NamespaceRegistry;
import org.modeshape.jcr.api.Repository;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

Expand Down

0 comments on commit f47ab78

Please sign in to comment.