inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-07-31 17:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed warnings from rm-server code

Browse Source 
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/modules/recordsmanagement/HEAD@83477 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Tuna Aksoy
2014-09-05 16:28:08 +00:00
parent 6a6be71f00
commit 0ccb56194d
3 changed files with 150 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
rm-server/source/java/org/alfresco/repo/model/filefolder/ExtendedFileFolderServiceImpl.java
View File

@@ -23,20 +23,7 @@ public class ExtendedFileFolderServiceImpl extends FileFolderServiceImpl
@Override @Override
public FileInfo create(NodeRef parentNodeRef, String name, QName typeQName) public FileInfo create(NodeRef parentNodeRef, String name, QName typeQName)
{ {
FileInfo result = null; return create(parentNodeRef, name, typeQName, null);
recordService.disablePropertyEditableCheck();
try
{
result = super.create(parentNodeRef, name, typeQName);
}
finally
{
recordService.enablePropertyEditableCheck();
recordService.disablePropertyEditableCheck(result.getNodeRef());
}
return result;
} }
@Override @Override
@@ -52,7 +39,10 @@ public class ExtendedFileFolderServiceImpl extends FileFolderServiceImpl
finally finally
{ {
recordService.enablePropertyEditableCheck(); recordService.enablePropertyEditableCheck();
recordService.disablePropertyEditableCheck(result.getNodeRef()); if (result != null)
{
recordService.disablePropertyEditableCheck(result.getNodeRef());
}
} }
return result; return result;

99
rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/system/DataLoadSystemTest.java
View File

@@ -46,7 +46,7 @@ public class DataLoadSystemTest
protected FilePlanRoleService filePlanRoleService; protected FilePlanRoleService filePlanRoleService;
protected SiteService siteService; protected SiteService siteService;
protected FileFolderService fileFolderService; protected FileFolderService fileFolderService;
/** config locations */ /** config locations */
protected String[] getConfigLocations() protected String[] getConfigLocations()
{ {
@@ -56,38 +56,38 @@ public class DataLoadSystemTest
"classpath:test-context.xml" "classpath:test-context.xml"
}; };
} }
/** transaction batch size */ /** transaction batch size */
private static final int BATCH_SIZE = 100; private static final int BATCH_SIZE = 100;
/** file plan sizing */ /** file plan sizing */
private static final int ROOT_CATEGORY_COUNT = 0; private static final int ROOT_CATEGORY_COUNT = 0;
private static final int RECORD_FOLDER_COUNT = 0; private static final int RECORD_FOLDER_COUNT = 0;
private static final int RECORD_COUNT = 0; private static final int RECORD_COUNT = 0;
/** rm user sizing */ /** rm user sizing */
private static final int RM_GROUP_COUNT = 0; private static final int RM_GROUP_COUNT = 0;
private static final int RM_USER_COUNT = 0; private static final int RM_USER_COUNT = 0;
/** inplace sizing */ /** inplace sizing */
private static final int USER_COUNT = 0; private static final int USER_COUNT = 0;
private static final int INPLACE_RECORD_COUNT = 5000; private static final int INPLACE_RECORD_COUNT = 5000;
/** application context */ /** application context */
private ApplicationContext applicationContext; private ApplicationContext applicationContext;
CommonRMTestUtils utils; CommonRMTestUtils utils;
private int totalCount; private int totalCount;
private List<NodeRef> recordCategories; private List<NodeRef> recordCategories;
private List<NodeRef> recordFolders; private List<NodeRef> recordFolders;
private List<String> groups; private List<String> groups;
@Before @Before
public void before() public void before()
{ {
applicationContext = ApplicationContextHelper.getApplicationContext(getConfigLocations()); applicationContext = ApplicationContextHelper.getApplicationContext(getConfigLocations());
utils = new CommonRMTestUtils(applicationContext); utils = new CommonRMTestUtils(applicationContext);
filePlanService = (FilePlanService)applicationContext.getBean("FilePlanService"); filePlanService = (FilePlanService)applicationContext.getBean("FilePlanService");
recordFolderService = (RecordFolderService)applicationContext.getBean("RecordFolderService"); recordFolderService = (RecordFolderService)applicationContext.getBean("RecordFolderService");
recordService = (RecordService)applicationContext.getBean("RecordService"); recordService = (RecordService)applicationContext.getBean("RecordService");
@@ -99,15 +99,15 @@ public class DataLoadSystemTest
siteService = (SiteService)applicationContext.getBean("siteService"); siteService = (SiteService)applicationContext.getBean("siteService");
fileFolderService = (FileFolderService)applicationContext.getBean("fileFolderService"); fileFolderService = (FileFolderService)applicationContext.getBean("fileFolderService");
} }
@Test @Test
public void loadAllData() public void loadAllData()
{ {
loadFilePlanData(); loadFilePlanData();
loadRMUsersAndGroups(); loadRMUsersAndGroups();
loadInPlace(); loadInPlace();
} }
private void loadInPlace() private void loadInPlace()
{ {
AuthenticationUtil.runAs(new RunAsWork<Void>() AuthenticationUtil.runAs(new RunAsWork<Void>()
@@ -118,14 +118,14 @@ public class DataLoadSystemTest
if (site == null) if (site == null)
{ {
Assert.fail("The collab site test is not present."); Assert.fail("The collab site test is not present.");
} }
final NodeRef filePlan = filePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID); final NodeRef filePlan = filePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
if (filePlan == null) if (filePlan == null)
{ {
Assert.fail("The default RM site is not present."); Assert.fail("The default RM site is not present.");
} }
// create users and add to site // create users and add to site
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
@@ -135,35 +135,36 @@ public class DataLoadSystemTest
String userName = GUID.generate(); String userName = GUID.generate();
System.out.println("Creating user " + userName); System.out.println("Creating user " + userName);
createPerson(userName, true); createPerson(userName, true);
// add to collab site // add to collab site
siteService.setMembership("test", userName, SiteRole.SiteCollaborator.toString()); siteService.setMembership("test", userName, SiteRole.SiteCollaborator.toString());
return null; return null;
} }
}, USER_COUNT); }, USER_COUNT);
// create content and declare as record // create content and declare as record
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
@SuppressWarnings("null")
public Void doWork() throws Exception public Void doWork() throws Exception
{ {
// create document // create document
NodeRef docLib = siteService.getContainer(site.getShortName(), SiteService.DOCUMENT_LIBRARY); NodeRef docLib = siteService.getContainer(site.getShortName(), SiteService.DOCUMENT_LIBRARY);
NodeRef document = fileFolderService.create(docLib, GUID.generate(), ContentModel.TYPE_CONTENT).getNodeRef(); NodeRef document = fileFolderService.create(docLib, GUID.generate(), ContentModel.TYPE_CONTENT).getNodeRef();
recordService.createRecord(filePlan, document); recordService.createRecord(filePlan, document);
return null; return null;
} }
}, INPLACE_RECORD_COUNT); }, INPLACE_RECORD_COUNT);
return null; return null;
} }
}, AuthenticationUtil.getAdminUserName()); }, AuthenticationUtil.getAdminUserName());
} }
private void loadRMUsersAndGroups() private void loadRMUsersAndGroups()
{ {
AuthenticationUtil.runAsSystem(new RunAsWork<Void>() AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
@@ -175,9 +176,9 @@ public class DataLoadSystemTest
{ {
Assert.fail("The default RM site is not present."); Assert.fail("The default RM site is not present.");
} }
groups = new ArrayList<String>(); groups = new ArrayList<String>();
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
public Void doWork() throws Exception public Void doWork() throws Exception
@@ -189,9 +190,9 @@ public class DataLoadSystemTest
return null; return null;
} }
}, RM_GROUP_COUNT); }, RM_GROUP_COUNT);
for (final String group : groups) for (final String group : groups)
{ {
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
public Void doWork() throws Exception public Void doWork() throws Exception
@@ -204,12 +205,12 @@ public class DataLoadSystemTest
} }
}, RM_USER_COUNT); }, RM_USER_COUNT);
} }
return null; return null;
} }
}); });
} }
private void loadFilePlanData() private void loadFilePlanData()
{ {
AuthenticationUtil.runAsSystem(new RunAsWork<Void>() AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
@@ -221,7 +222,7 @@ public class DataLoadSystemTest
{ {
Assert.fail("The default RM site is not present."); Assert.fail("The default RM site is not present.");
} }
// create root categories // create root categories
recordCategories = new ArrayList<NodeRef>(ROOT_CATEGORY_COUNT); recordCategories = new ArrayList<NodeRef>(ROOT_CATEGORY_COUNT);
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
@@ -232,11 +233,11 @@ public class DataLoadSystemTest
return null; return null;
} }
}, ROOT_CATEGORY_COUNT); }, ROOT_CATEGORY_COUNT);
// create record folders // create record folders
recordFolders = new ArrayList<NodeRef>(RECORD_FOLDER_COUNT); recordFolders = new ArrayList<NodeRef>(RECORD_FOLDER_COUNT);
for (final NodeRef recordCategory : recordCategories) for (final NodeRef recordCategory : recordCategories)
{ {
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
public Void doWork() throws Exception public Void doWork() throws Exception
@@ -246,10 +247,10 @@ public class DataLoadSystemTest
} }
}, RECORD_FOLDER_COUNT); }, RECORD_FOLDER_COUNT);
} }
// create records // create records
for (final NodeRef recordFolder : recordFolders) for (final NodeRef recordFolder : recordFolders)
{ {
repeatInTransactionBatches(new RunAsWork<Void>() repeatInTransactionBatches(new RunAsWork<Void>()
{ {
public Void doWork() throws Exception public Void doWork() throws Exception
@@ -259,13 +260,13 @@ public class DataLoadSystemTest
} }
}, RECORD_COUNT); }, RECORD_COUNT);
} }
return null; return null;
} }
}); });
} }
private NodeRef createPerson(String userName, boolean createAuth) private NodeRef createPerson(String userName, boolean createAuth)
{ {
if (createAuth) if (createAuth)
@@ -276,7 +277,7 @@ public class DataLoadSystemTest
properties.put(ContentModel.PROP_USERNAME, userName); properties.put(ContentModel.PROP_USERNAME, userName);
return personService.createPerson(properties); return personService.createPerson(properties);
} }
private void repeatInTransactionBatches(final RunAsWork<Void> work, final int count) throws Exception private void repeatInTransactionBatches(final RunAsWork<Void> work, final int count) throws Exception
{ {
totalCount = 0; totalCount = 0;
@@ -291,19 +292,19 @@ public class DataLoadSystemTest
{ {
batchSize = BATCH_SIZE; batchSize = BATCH_SIZE;
} }
for (int i = 0; i < batchSize; i++) for (int i = 0; i < batchSize; i++)
{ {
// do it // do it
work.doWork(); work.doWork();
totalCount++; totalCount++;
} }
System.out.println("Created " + totalCount + " of " + count); System.out.println("Created " + totalCount + " of " + count);
return null; return null;
} }
}, },
false, true); false, true);
} }
} }

192
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/version/RecordableVersionServiceImplUnitTest.java
View File

@@ -20,13 +20,13 @@ package org.alfresco.module.org_alfresco_module_rm.version;
import static org.mockito.Matchers.any; import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyMap; import static org.mockito.Matchers.anyMap;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq; import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never; import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times; import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.anyString;
import java.io.Serializable; import java.io.Serializable;
import java.util.Collections; import java.util.Collections;
@@ -38,7 +38,6 @@ import org.alfresco.model.ContentModel;
import org.alfresco.module.org_alfresco_module_rm.fileplan.FilePlanService; import org.alfresco.module.org_alfresco_module_rm.fileplan.FilePlanService;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest;
import org.alfresco.repo.version.Version2Model; import org.alfresco.repo.version.Version2Model;
import org.alfresco.repo.version.VersionMigrator;
import org.alfresco.repo.version.VersionModel; import org.alfresco.repo.version.VersionModel;
import org.alfresco.service.cmr.model.FileInfo; import org.alfresco.service.cmr.model.FileInfo;
import org.alfresco.service.cmr.repository.NodeRef; import org.alfresco.service.cmr.repository.NodeRef;
@@ -51,28 +50,27 @@ import org.mockito.Mock;
/** /**
* Recordable version service implementation unit test. * Recordable version service implementation unit test.
* *
* @author Roy Wetherall * @author Roy Wetherall
* @since 2.3 * @since 2.3
*/ */
public class RecordableVersionServiceImplUnitTest extends BaseUnitTest public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
{ {
/** versioned content name */ /** versioned content name */
private static final String CONTENT_NAME = "test.txt"; private static final String CONTENT_NAME = "test.txt";
/** versioned node reference */ /** versioned node reference */
private NodeRef nodeRef; private NodeRef nodeRef;
private NodeRef record; private NodeRef record;
private NodeRef unfiledRecordContainer; private NodeRef unfiledRecordContainer;
private NodeRef version; private NodeRef version;
/** mocked version properties */ /** mocked version properties */
private Map<String, Serializable> versionProperties; private Map<String, Serializable> versionProperties;
/** mocked services */ /** mocked services */
private @Mock(name="versionMigrator") VersionMigrator mockedVersionMigrator;
private @Mock(name="dbNodeService") NodeService mockedDbNodeService; private @Mock(name="dbNodeService") NodeService mockedDbNodeService;
/** recordable version service */ /** recordable version service */
private @InjectMocks TestRecordableVersionServiceImpl recordableVersionService; private @InjectMocks TestRecordableVersionServiceImpl recordableVersionService;
@@ -83,15 +81,15 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
@Override @Override
public void before() throws Exception public void before() throws Exception
{ {
super.before(); super.before();
nodeRef = generateCmContent(CONTENT_NAME); nodeRef = generateCmContent(CONTENT_NAME);
doReturn(123l).when(mockedNodeService).getProperty(nodeRef, ContentModel.PROP_NODE_DBID); doReturn(123l).when(mockedNodeService).getProperty(nodeRef, ContentModel.PROP_NODE_DBID);
versionProperties = new HashMap<String, Serializable>(5); versionProperties = new HashMap<String, Serializable>(5);
recordableVersionService.initialise(); recordableVersionService.initialise();
doReturn(generateChildAssociationRef(null, generateNodeRef(Version2Model.TYPE_QNAME_VERSION_HISTORY))) doReturn(generateChildAssociationRef(null, generateNodeRef(Version2Model.TYPE_QNAME_VERSION_HISTORY)))
.when(mockedDbNodeService).createNode(any(NodeRef.class), .when(mockedDbNodeService).createNode(any(NodeRef.class),
any(QName.class), any(QName.class),
@@ -104,28 +102,28 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
any(QName.class), any(QName.class),
eq(TYPE_CONTENT), eq(TYPE_CONTENT),
anyMap()); anyMap());
doReturn(filePlan).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID); doReturn(filePlan).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
doReturn(unfiledRecordContainer).when(mockedFilePlanService).getUnfiledContainer(any(NodeRef.class)); doReturn(unfiledRecordContainer).when(mockedFilePlanService).getUnfiledContainer(any(NodeRef.class));
record = generateCmContent(CONTENT_NAME); record = generateCmContent(CONTENT_NAME);
FileInfo mockedFileInfo = mock(FileInfo.class); FileInfo mockedFileInfo = mock(FileInfo.class);
doReturn(record).when(mockedFileInfo).getNodeRef(); doReturn(record).when(mockedFileInfo).getNodeRef();
doReturn(mockedFileInfo).when(mockedFileFolderService).copy(any(NodeRef.class), doReturn(mockedFileInfo).when(mockedFileFolderService).copy(any(NodeRef.class),
any(NodeRef.class), any(NodeRef.class),
any(String.class)); any(String.class));
version = generateNodeRef(TYPE_CONTENT); version = generateNodeRef(TYPE_CONTENT);
doReturn(generateChildAssociationRef(null, version)).when(mockedDbNodeService).createNode( doReturn(generateChildAssociationRef(null, version)).when(mockedDbNodeService).createNode(
any(NodeRef.class), any(NodeRef.class),
eq(Version2Model.CHILD_QNAME_VERSIONS), eq(Version2Model.CHILD_QNAME_VERSIONS),
any(QName.class), any(QName.class),
eq(TYPE_CONTENT), eq(TYPE_CONTENT),
anyMap()); anyMap());
} }
/** /**
* Given that the node has no recordable version aspect * Given that the node has no recordable version aspect
* When I create a version * When I create a version
* Then version service creates a normal version. * Then version service creates a normal version.
*/ */
@Test @Test
@@ -134,17 +132,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
// setup given conditions // setup given conditions
doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created // then a normal version is created
verifyNormalVersion(); verifyNormalVersion();
} }
/** /**
* Given that the node has a recordable version policy of null * Given that the node has a recordable version policy of null
* When I create a version * When I create a version
* Then the version service creates a normal version. * Then the version service creates a normal version.
*/ */
@Test @Test
@@ -154,17 +152,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(null).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(null).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created // then a normal version is created
verifyNormalVersion(); verifyNormalVersion();
} }
/** /**
* Given that the node has a recordable version policy of NONE * Given that the node has a recordable version policy of NONE
* When I create a version * When I create a version
* Then the version service creates a normal version. * Then the version service creates a normal version.
*/ */
@Test @Test
@@ -174,17 +172,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.NONE.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.NONE.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created // then a normal version is created
verifyNormalVersion(); verifyNormalVersion();
} }
/** /**
* Given that the node has a recordable version policy of ALL * Given that the node has a recordable version policy of ALL
* When I create a MINOR version then * When I create a MINOR version then
* the version service creates a recorded version * the version service creates a recorded version
*/ */
@Test @Test
@@ -194,15 +192,15 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(filePlan); verifyRecordedVersion(filePlan);
} }
/** /**
* Helper method that verifies that a recorded version was created. * Helper method that verifies that a recorded version was created.
*/ */
@@ -211,23 +209,23 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
{ {
// then unfiled container is retrieved for file plan // then unfiled container is retrieved for file plan
verify(mockedFilePlanService, times(1)).getUnfiledContainer(filePlan); verify(mockedFilePlanService, times(1)).getUnfiledContainer(filePlan);
// then the node is copied into the file plan // then the node is copied into the file plan
verify(mockedFileFolderService, times(1)).copy(eq(nodeRef), verify(mockedFileFolderService, times(1)).copy(eq(nodeRef),
eq(unfiledRecordContainer), eq(unfiledRecordContainer),
anyString()); anyString());
// then the version is created // then the version is created
verify(mockedDbNodeService, times(1)).createNode(any(NodeRef.class), verify(mockedDbNodeService, times(1)).createNode(any(NodeRef.class),
eq(Version2Model.CHILD_QNAME_VERSIONS), eq(Version2Model.CHILD_QNAME_VERSIONS),
any(QName.class), any(QName.class),
eq(TYPE_CONTENT), eq(TYPE_CONTENT),
anyMap()); anyMap());
verify(mockedNodeService, times(1)).addAspect(eq(version), eq(Version2Model.ASPECT_VERSION), anyMap()); verify(mockedNodeService, times(1)).addAspect(eq(version), eq(Version2Model.ASPECT_VERSION), anyMap());
verify(mockedNodeService, times(1)).addAspect(eq(version), eq(RecordableVersionModel.ASPECT_RECORDED_VERSION), verify(mockedNodeService, times(1)).addAspect(eq(version), eq(RecordableVersionModel.ASPECT_RECORDED_VERSION),
eq(Collections.singletonMap(RecordableVersionModel.PROP_RECORD_NODE_REF, (Serializable)record))); eq(Collections.singletonMap(RecordableVersionModel.PROP_RECORD_NODE_REF, (Serializable)record)));
} }
/** /**
* Helper method that verified that a recorded version was not created. * Helper method that verified that a recorded version was not created.
*/ */
@@ -235,24 +233,24 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
private void verifyNormalVersion() throws Exception private void verifyNormalVersion() throws Exception
{ {
// verify no interactions // verify no interactions
verify(mockedFilePlanService, never()).getUnfiledContainer(any(NodeRef.class)); verify(mockedFilePlanService, never()).getUnfiledContainer(any(NodeRef.class));
verify(mockedFileFolderService, never()).copy(eq(nodeRef), verify(mockedFileFolderService, never()).copy(eq(nodeRef),
eq(unfiledRecordContainer), eq(unfiledRecordContainer),
anyString()); anyString());
// then the version is created // then the version is created
verify(mockedDbNodeService, times(1)).createNode(any(NodeRef.class), verify(mockedDbNodeService, times(1)).createNode(any(NodeRef.class),
eq(Version2Model.CHILD_QNAME_VERSIONS), eq(Version2Model.CHILD_QNAME_VERSIONS),
any(QName.class), any(QName.class),
eq(TYPE_CONTENT), eq(TYPE_CONTENT),
anyMap()); anyMap());
verify(mockedNodeService, times(1)).addAspect(eq(version), eq(Version2Model.ASPECT_VERSION), anyMap()); verify(mockedNodeService, times(1)).addAspect(eq(version), eq(Version2Model.ASPECT_VERSION), anyMap());
verify(mockedNodeService, never()).addAspect(eq(version), eq(RecordableVersionModel.PROP_RECORD_NODE_REF), anyMap()); verify(mockedNodeService, never()).addAspect(eq(version), eq(RecordableVersionModel.PROP_RECORD_NODE_REF), anyMap());
} }
/** /**
* Given that the node has a recordable version policy of ALL * Given that the node has a recordable version policy of ALL
* When I create a MAJOR version then * When I create a MAJOR version then
* the version service creates a recorded version * the version service creates a recorded version
*/ */
@Test @Test
@@ -262,18 +260,18 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(filePlan); verifyRecordedVersion(filePlan);
} }
/** /**
* Given that the node has a recordable version policy of MAJOR_ONLY * Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MINOR version then * When I create a MINOR version then
* the version service creates a normal version * the version service creates a normal version
*/ */
@Test @Test
@@ -283,17 +281,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created // then a normal version is created
verifyNormalVersion(); verifyNormalVersion();
} }
/** /**
* Given that the node has a recordable version policy of MAJOR_ONLY * Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MAJOR version then * When I create a MAJOR version then
* the version service creates a recorded version * the version service creates a recorded version
*/ */
@Test @Test
@@ -303,14 +301,14 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(filePlan); verifyRecordedVersion(filePlan);
} }
/** /**
* Given that the node has a valid recordable version policy * Given that the node has a valid recordable version policy
* And there is no file plan * And there is no file plan
@@ -325,14 +323,14 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
doReturn(null).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID); doReturn(null).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
// expected exception // expected exception
exception.expect(AlfrescoRuntimeException.class); exception.expect(AlfrescoRuntimeException.class);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
} }
/** /**
* Given that the node has a valid recordable version policy * Given that the node has a valid recordable version policy
* And that I set a specific file plan in the version properties * And that I set a specific file plan in the version properties
@@ -346,18 +344,18 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// specify the file plan // specify the file plan
NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN); NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN);
versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan); versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(anotherFilePlan); verifyRecordedVersion(anotherFilePlan);
} }
/** /**
* Given that the node has specifically indicated that a recorded version should be created * Given that the node has specifically indicated that a recorded version should be created
* And that I set a specific file plan in the version properties * And that I set a specific file plan in the version properties
@@ -371,18 +369,18 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true); versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// specify the file plan // specify the file plan
NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN); NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN);
versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan); versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(anotherFilePlan); verifyRecordedVersion(anotherFilePlan);
} }
@Test @Test
public void adHocRecordedVersionNoPolicy() throws Exception public void adHocRecordedVersionNoPolicy() throws Exception
{ {
@@ -390,14 +388,14 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE); doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true); versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(filePlan); verifyRecordedVersion(filePlan);
} }
@Test @Test
public void adHocRecordedVersionOverridePolicy() throws Exception public void adHocRecordedVersionOverridePolicy() throws Exception
{ {
@@ -406,11 +404,11 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY); doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR); versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true); versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// when version is created // when version is created
recordableVersionService.createVersion(nodeRef, versionProperties); recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created // then the recorded version is created
verifyRecordedVersion(filePlan); verifyRecordedVersion(filePlan);
} }
} }