Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
unit testing ObjectService and DatastreamService
  • Loading branch information
barmintor committed Apr 2, 2013
1 parent 718e9bb commit 15a3b42
Show file tree
Hide file tree
Showing 3 changed files with 222 additions and 9 deletions.
Expand Up @@ -77,7 +77,7 @@ public void updateRepositorySize(Long change, Session session)
final Node objectStore = findOrCreateNode(session, "/objects");


Property sizeProperty = objectStore.getProperty("fedora:size");
Property sizeProperty = objectStore.getProperty(FEDORA_SIZE);

Long previousSize = sizeProperty.getLong();
logger.debug("Previous repository size: " + previousSize);
Expand Down
@@ -0,0 +1,142 @@
package org.fcrepo.services;

import static org.fcrepo.services.PathService.getDatastreamJcrNodePath;
import static org.fcrepo.services.PathService.getObjectJcrNodePath;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
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.verifyNew;
import static org.powermock.api.mockito.PowerMockito.whenNew;

import java.io.InputStream;

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

import org.fcrepo.Datastream;
import org.fcrepo.FedoraObject;
import org.fcrepo.utils.DatastreamIterator;
import org.fcrepo.utils.FedoraJcrTypes;
import org.fcrepo.utils.FedoraTypesUtils;
import org.junit.After;
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( { DatastreamService.class, FedoraTypesUtils.class, ServiceHelpers.class })
public class DatastreamServiceTest implements FedoraJcrTypes {

private static final String MOCK_CONTENT_TYPE = "application/test-data";

@Before
public void setUp() {
}

@After
public void tearDown() {

}

@Test
public void testCreateDatastreamNode() throws Exception {
final Node mockNode = mock(Node.class);
Session mockSession = mock(Session.class);
InputStream mockIS = mock(InputStream.class);
String testPath = getDatastreamJcrNodePath("foo", "bar");
Datastream mockWrapper = mock(Datastream.class);
when(mockWrapper.getNode()).thenReturn(mockNode);
whenNew(Datastream.class)
.withArguments(mockSession, testPath)
.thenReturn(mockWrapper);
DatastreamService testObj = new DatastreamService();
Node actual = testObj.createDatastreamNode(mockSession, testPath, MOCK_CONTENT_TYPE, mockIS);
assertEquals(mockNode, actual);
verifyNew(Datastream.class)
.withArguments(mockSession, testPath);
verify(mockWrapper).setContent(eq(mockIS), any(String.class), any(String.class), any(String.class));
}

@Test
public void testGetDatastreamNode() throws Exception {
Session mockSession = mock(Session.class);
final Node mockNode = mock(Node.class);
Datastream mockWrapper = mock(Datastream.class);
when(mockWrapper.getNode()).thenReturn(mockNode);
whenNew(Datastream.class)
.withArguments(mockSession, "foo", "bar")
.thenReturn(mockWrapper);
DatastreamService testObj = new DatastreamService();
testObj.readOnlySession = mockSession;
testObj.getDatastreamNode("foo", "bar");
verifyNew(Datastream.class)
.withArguments(mockSession, "foo", "bar");
verify(mockWrapper).getNode();
}

@Test
public void testGetDatastream() throws Exception {
Session mockSession = mock(Session.class);
final Node mockNode = mock(Node.class);
Datastream mockWrapper = mock(Datastream.class);
when(mockWrapper.getNode()).thenReturn(mockNode);
whenNew(Datastream.class)
.withArguments(mockSession, "foo", "bar")
.thenReturn(mockWrapper);
DatastreamService testObj = new DatastreamService();
testObj.readOnlySession = mockSession;
testObj.getDatastream("foo", "bar");
verifyNew(Datastream.class)
.withArguments(mockSession, "foo", "bar");
}

@Test
public void testPurgeDatastream() throws Exception {
Session mockSession = mock(Session.class);
final Node mockNode = mock(Node.class);
Datastream mockWrapper = mock(Datastream.class);
when(mockWrapper.getNode()).thenReturn(mockNode);
whenNew(Datastream.class)
.withArguments(mockSession, "foo", "bar")
.thenReturn(mockWrapper);
DatastreamService testObj = new DatastreamService();
testObj.purgeDatastream(mockSession, "foo", "bar");
verifyNew(Datastream.class)
.withArguments(mockSession, "foo", "bar");
verify(mockWrapper).purge();
}

@Test
public void testGetDatastreamsFor() throws Exception {
Session mockSession = mock(Session.class);
Node mockObjNode = mock(Node.class);
FedoraObject mockObj = mock(FedoraObject.class);
when(mockObj.getNode()).thenReturn(mockObjNode);
whenNew(FedoraObject.class)
.withArguments(mockSession, getObjectJcrNodePath("foo"))
.thenReturn(mockObj);
DatastreamService testObj = new DatastreamService();
testObj.readOnlySession = mockSession;
DatastreamIterator actual = testObj.getDatastreamsFor("foo");
assertNotNull(actual);
verifyNew(FedoraObject.class)
.withArguments(mockSession, getObjectJcrNodePath("foo"));
verify(mockObjNode).getNodes();
}

@Test
public void testExists() throws RepositoryException {
Session mockSession = mock(Session.class);
DatastreamService testObj = new DatastreamService();
testObj.readOnlySession = mockSession;
testObj.exists("foo", "bar");
verify(mockSession).nodeExists(getDatastreamJcrNodePath("foo", "bar"));
}
}
Expand Up @@ -2,32 +2,35 @@

import static org.fcrepo.services.PathService.getObjectJcrNodePath;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.any;
import static org.mockito.Matchers.any;
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.verifyStatic;
import static org.powermock.api.mockito.PowerMockito.whenNew;
import static org.powermock.api.mockito.PowerMockito.verifyNew;
import static org.powermock.api.mockito.PowerMockito.whenNew;

import java.security.SecureRandom;
import java.util.Set;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.fcrepo.FedoraObject;
import org.fcrepo.utils.FedoraJcrTypes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest(ObjectService.class)
public class ObjectServiceTest {
@PrepareForTest( { ObjectService.class, ServiceHelpers.class })
public class ObjectServiceTest implements FedoraJcrTypes {

@Before
public void setUp() {
Expand Down Expand Up @@ -68,4 +71,72 @@ public void testCreateObject() throws Exception {
verifyNew(FedoraObject.class)
.withArguments(mockSession, testPath);
}

@Test
public void testGetObject() throws RepositoryException {
Session mockSession = mock(Session.class);
Session mockROSession = mock(Session.class);
String testPath = getObjectJcrNodePath("foo");
ObjectService testObj = new ObjectService();
testObj.readOnlySession = mockROSession;
testObj.getObject("foo");
testObj.getObject(mockSession, "foo");
verify(mockROSession).getNode(testPath);
verify(mockSession).getNode(testPath);
}

@Test
public void testGetObjectNode() throws RepositoryException {
Session mockSession = mock(Session.class);
Session mockROSession = mock(Session.class);
String testPath = getObjectJcrNodePath("foo");
ObjectService testObj = new ObjectService();
testObj.readOnlySession = mockROSession;
testObj.getObjectNode("foo");
testObj.getObjectNode(mockSession, "foo");
verify(mockROSession).getNode(testPath);
verify(mockSession).getNode(testPath);
}

@Test
public void testGetObjectNames() throws RepositoryException {
String objPath = getObjectJcrNodePath("");
Session mockSession = mock(Session.class);
Node mockRoot = mock(Node.class);
Node mockObj = mock(Node.class);
when(mockObj.getName()).thenReturn("foo");
NodeIterator mockIter = mock(NodeIterator.class);
when(mockIter.hasNext()).thenReturn(true, false);
when(mockIter.nextNode()).thenReturn(mockObj).thenThrow(IndexOutOfBoundsException.class);
when(mockRoot.getNodes()).thenReturn(mockIter);
when(mockSession.getNode(objPath)).thenReturn(mockRoot);
ObjectService testObj = new ObjectService();
testObj.readOnlySession = mockSession;
Set<String> actual = testObj.getObjectNames();
verify(mockSession).getNode(objPath);
assertEquals(1, actual.size());
assertEquals("foo", actual.iterator().next());
}

@Test
public void testDeleteOBject() throws RepositoryException {
String objPath = getObjectJcrNodePath("foo");
Session mockSession = mock(Session.class);
Node mockRootNode = mock(Node.class);
Node mockObjectsNode = mock(Node.class);
Property mockProp = mock(Property.class);
Node mockObjNode = mock(Node.class);
when(mockObjectsNode.getProperty(FEDORA_SIZE)).thenReturn(mockProp);
when(mockSession.getRootNode()).thenReturn(mockRootNode);
when(mockRootNode.getNode("objects")).thenReturn(mockObjectsNode);
when(mockSession.getNode(objPath)).thenReturn(mockObjNode);
PowerMockito.mockStatic(ServiceHelpers.class);
long mockSize = new SecureRandom().nextLong();
when(ServiceHelpers.getObjectSize(mockObjNode)).thenReturn(mockSize); // testing with a random value
ObjectService testObj = new ObjectService();
testObj.deleteObject("foo", mockSession);
verify(mockSession).getNode(objPath);
verify(mockObjNode).remove();
verify(mockProp).setValue(0 - mockSize);
}
}

0 comments on commit 15a3b42

Please sign in to comment.