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
public FileInfo create(NodeRef parentNodeRef, String name, QName typeQName)
{
FileInfo result = null;
recordService.disablePropertyEditableCheck();
try
{
result = super.create(parentNodeRef, name, typeQName);
}
finally
{
recordService.enablePropertyEditableCheck();
recordService.disablePropertyEditableCheck(result.getNodeRef());
}
return result;
return create(parentNodeRef, name, typeQName, null);
}
@Override
@@ -52,7 +39,10 @@ public class ExtendedFileFolderServiceImpl extends FileFolderServiceImpl
finally
{
recordService.enablePropertyEditableCheck();
recordService.disablePropertyEditableCheck(result.getNodeRef());
if (result != null)
{
recordService.disablePropertyEditableCheck(result.getNodeRef());
}
}
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 SiteService siteService;
protected FileFolderService fileFolderService;
/** config locations */
protected String[] getConfigLocations()
{
@@ -56,38 +56,38 @@ public class DataLoadSystemTest
"classpath:test-context.xml"
};
}
/** transaction batch size */
private static final int BATCH_SIZE = 100;
/** file plan sizing */
private static final int ROOT_CATEGORY_COUNT = 0;
/** file plan sizing */
private static final int ROOT_CATEGORY_COUNT = 0;
private static final int RECORD_FOLDER_COUNT = 0;
private static final int RECORD_COUNT = 0;
/** rm user sizing */
private static final int RM_GROUP_COUNT = 0;
private static final int RM_USER_COUNT = 0;
/** inplace sizing */
private static final int USER_COUNT = 0;
private static final int INPLACE_RECORD_COUNT = 5000;
/** application context */
/** application context */
private ApplicationContext applicationContext;
CommonRMTestUtils utils;
private int totalCount;
private List<NodeRef> recordCategories;
private List<NodeRef> recordFolders;
private List<String> groups;
@Before
public void before()
{
applicationContext = ApplicationContextHelper.getApplicationContext(getConfigLocations());
utils = new CommonRMTestUtils(applicationContext);
filePlanService = (FilePlanService)applicationContext.getBean("FilePlanService");
recordFolderService = (RecordFolderService)applicationContext.getBean("RecordFolderService");
recordService = (RecordService)applicationContext.getBean("RecordService");
@@ -99,15 +99,15 @@ public class DataLoadSystemTest
siteService = (SiteService)applicationContext.getBean("siteService");
fileFolderService = (FileFolderService)applicationContext.getBean("fileFolderService");
}
@Test
public void loadAllData()
{
loadFilePlanData();
loadFilePlanData();
loadRMUsersAndGroups();
loadInPlace();
}
private void loadInPlace()
{
AuthenticationUtil.runAs(new RunAsWork<Void>()
@@ -118,14 +118,14 @@ public class DataLoadSystemTest
if (site == null)
{
Assert.fail("The collab site test is not present.");
}
}
final NodeRef filePlan = filePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
if (filePlan == null)
{
Assert.fail("The default RM site is not present.");
}
// create users and add to site
repeatInTransactionBatches(new RunAsWork<Void>()
{
@@ -135,35 +135,36 @@ public class DataLoadSystemTest
String userName = GUID.generate();
System.out.println("Creating user " + userName);
createPerson(userName, true);
// add to collab site
siteService.setMembership("test", userName, SiteRole.SiteCollaborator.toString());
return null;
}
}, USER_COUNT);
// create content and declare as record
repeatInTransactionBatches(new RunAsWork<Void>()
{
@SuppressWarnings("null")
public Void doWork() throws Exception
{
// create document
NodeRef docLib = siteService.getContainer(site.getShortName(), SiteService.DOCUMENT_LIBRARY);
NodeRef document = fileFolderService.create(docLib, GUID.generate(), ContentModel.TYPE_CONTENT).getNodeRef();
recordService.createRecord(filePlan, document);
return null;
}
}, INPLACE_RECORD_COUNT);
return null;
}
}, AuthenticationUtil.getAdminUserName());
}
private void loadRMUsersAndGroups()
{
AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
@@ -175,9 +176,9 @@ public class DataLoadSystemTest
{
Assert.fail("The default RM site is not present.");
}
groups = new ArrayList<String>();
repeatInTransactionBatches(new RunAsWork<Void>()
{
public Void doWork() throws Exception
@@ -189,9 +190,9 @@ public class DataLoadSystemTest
return null;
}
}, RM_GROUP_COUNT);
for (final String group : groups)
{
{
repeatInTransactionBatches(new RunAsWork<Void>()
{
public Void doWork() throws Exception
@@ -204,12 +205,12 @@ public class DataLoadSystemTest
}
}, RM_USER_COUNT);
}
return null;
}
});
});
}
private void loadFilePlanData()
{
AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
@@ -221,7 +222,7 @@ public class DataLoadSystemTest
{
Assert.fail("The default RM site is not present.");
}
// create root categories
recordCategories = new ArrayList<NodeRef>(ROOT_CATEGORY_COUNT);
repeatInTransactionBatches(new RunAsWork<Void>()
@@ -232,11 +233,11 @@ public class DataLoadSystemTest
return null;
}
}, ROOT_CATEGORY_COUNT);
// create record folders
recordFolders = new ArrayList<NodeRef>(RECORD_FOLDER_COUNT);
for (final NodeRef recordCategory : recordCategories)
{
{
repeatInTransactionBatches(new RunAsWork<Void>()
{
public Void doWork() throws Exception
@@ -246,10 +247,10 @@ public class DataLoadSystemTest
}
}, RECORD_FOLDER_COUNT);
}
// create records
for (final NodeRef recordFolder : recordFolders)
{
{
repeatInTransactionBatches(new RunAsWork<Void>()
{
public Void doWork() throws Exception
@@ -259,13 +260,13 @@ public class DataLoadSystemTest
}
}, RECORD_COUNT);
}
return null;
}
});
}
});
}
private NodeRef createPerson(String userName, boolean createAuth)
{
if (createAuth)
@@ -276,7 +277,7 @@ public class DataLoadSystemTest
properties.put(ContentModel.PROP_USERNAME, userName);
return personService.createPerson(properties);
}
private void repeatInTransactionBatches(final RunAsWork<Void> work, final int count) throws Exception
{
totalCount = 0;
@@ -291,19 +292,19 @@ public class DataLoadSystemTest
{
batchSize = BATCH_SIZE;
}
for (int i = 0; i < batchSize; i++)
{
// do it
work.doWork();
work.doWork();
totalCount++;
}
System.out.println("Created " + totalCount + " of " + count);
return null;
}
},
},
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.anyMap;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.anyString;
import java.io.Serializable;
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.test.util.BaseUnitTest;
import org.alfresco.repo.version.Version2Model;
import org.alfresco.repo.version.VersionMigrator;
import org.alfresco.repo.version.VersionModel;
import org.alfresco.service.cmr.model.FileInfo;
import org.alfresco.service.cmr.repository.NodeRef;
@@ -51,28 +50,27 @@ import org.mockito.Mock;
/**
* Recordable version service implementation unit test.
*
*
* @author Roy Wetherall
* @since 2.3
*/
public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
{
/** versioned content name */
private static final String CONTENT_NAME = "test.txt";
/** versioned node reference */
private NodeRef nodeRef;
private NodeRef record;
private NodeRef unfiledRecordContainer;
private NodeRef version;
/** mocked version properties */
private Map<String, Serializable> versionProperties;
/** mocked services */
private @Mock(name="versionMigrator") VersionMigrator mockedVersionMigrator;
private @Mock(name="dbNodeService") NodeService mockedDbNodeService;
/** recordable version service */
private @InjectMocks TestRecordableVersionServiceImpl recordableVersionService;
@@ -83,15 +81,15 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
@Override
public void before() throws Exception
{
super.before();
nodeRef = generateCmContent(CONTENT_NAME);
super.before();
nodeRef = generateCmContent(CONTENT_NAME);
doReturn(123l).when(mockedNodeService).getProperty(nodeRef, ContentModel.PROP_NODE_DBID);
versionProperties = new HashMap<String, Serializable>(5);
recordableVersionService.initialise();
doReturn(generateChildAssociationRef(null, generateNodeRef(Version2Model.TYPE_QNAME_VERSION_HISTORY)))
.when(mockedDbNodeService).createNode(any(NodeRef.class),
any(QName.class),
@@ -104,28 +102,28 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
any(QName.class),
eq(TYPE_CONTENT),
anyMap());
doReturn(filePlan).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
doReturn(unfiledRecordContainer).when(mockedFilePlanService).getUnfiledContainer(any(NodeRef.class));
record = generateCmContent(CONTENT_NAME);
FileInfo mockedFileInfo = mock(FileInfo.class);
doReturn(record).when(mockedFileInfo).getNodeRef();
doReturn(mockedFileInfo).when(mockedFileFolderService).copy(any(NodeRef.class),
any(NodeRef.class),
doReturn(mockedFileInfo).when(mockedFileFolderService).copy(any(NodeRef.class),
any(NodeRef.class),
any(String.class));
version = generateNodeRef(TYPE_CONTENT);
doReturn(generateChildAssociationRef(null, version)).when(mockedDbNodeService).createNode(
any(NodeRef.class),
any(NodeRef.class),
eq(Version2Model.CHILD_QNAME_VERSIONS),
any(QName.class),
eq(TYPE_CONTENT),
any(QName.class),
eq(TYPE_CONTENT),
anyMap());
}
/**
* Given that the node has no recordable version aspect
* When I create a version
* Given that the node has no recordable version aspect
* When I create a version
* Then version service creates a normal version.
*/
@Test
@@ -134,17 +132,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
// setup given conditions
doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created
verifyNormalVersion();
}
/**
* Given that the node has a recordable version policy of null
* When I create a version
* Given that the node has a recordable version policy of null
* When I create a version
* Then the version service creates a normal version.
*/
@Test
@@ -154,17 +152,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(false).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(null).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created
verifyNormalVersion();
}
/**
* Given that the node has a recordable version policy of NONE
* When I create a version
* Given that the node has a recordable version policy of NONE
* When I create a version
* Then the version service creates a normal version.
*/
@Test
@@ -174,17 +172,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.NONE.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created
verifyNormalVersion();
}
/**
* Given that the node has a recordable version policy of ALL
* When I create a MINOR version then
* Given that the node has a recordable version policy of ALL
* When I create a MINOR version then
* the version service creates a recorded version
*/
@Test
@@ -194,15 +192,15 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(filePlan);
}
/**
* 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
verify(mockedFilePlanService, times(1)).getUnfiledContainer(filePlan);
// then the node is copied into the file plan
verify(mockedFileFolderService, times(1)).copy(eq(nodeRef),
eq(unfiledRecordContainer),
verify(mockedFileFolderService, times(1)).copy(eq(nodeRef),
eq(unfiledRecordContainer),
anyString());
// 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),
any(QName.class),
eq(TYPE_CONTENT),
anyMap());
any(QName.class),
eq(TYPE_CONTENT),
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)));
}
/**
* 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
{
// verify no interactions
verify(mockedFilePlanService, never()).getUnfiledContainer(any(NodeRef.class));
verify(mockedFileFolderService, never()).copy(eq(nodeRef),
eq(unfiledRecordContainer),
verify(mockedFilePlanService, never()).getUnfiledContainer(any(NodeRef.class));
verify(mockedFileFolderService, never()).copy(eq(nodeRef),
eq(unfiledRecordContainer),
anyString());
// 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),
any(QName.class),
eq(TYPE_CONTENT),
any(QName.class),
eq(TYPE_CONTENT),
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());
}
/**
* Given that the node has a recordable version policy of ALL
* When I create a MAJOR version then
* Given that the node has a recordable version policy of ALL
* When I create a MAJOR version then
* the version service creates a recorded version
*/
@Test
@@ -262,18 +260,18 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.ALL.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(filePlan);
}
/**
* Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MINOR version then
* Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MINOR version then
* the version service creates a normal version
*/
@Test
@@ -283,17 +281,17 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then a normal version is created
verifyNormalVersion();
}
/**
* Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MAJOR version then
* Given that the node has a recordable version policy of MAJOR_ONLY
* When I create a MAJOR version then
* the version service creates a recorded version
*/
@Test
@@ -303,14 +301,14 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
doReturn(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(filePlan);
}
/**
* Given that the node has a valid recordable version policy
* 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);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
doReturn(null).when(mockedFilePlanService).getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID);
// expected exception
exception.expect(AlfrescoRuntimeException.class);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
}
/**
* Given that the node has a valid recordable version policy
* 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(RecordableVersionPolicy.MAJOR_ONLY.toString()).when(mockedNodeService).getProperty(nodeRef, RecordableVersionModel.PROP_RECORDABLE_VERSION_POLICY);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
// specify the file plan
NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN);
versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(anotherFilePlan);
verifyRecordedVersion(anotherFilePlan);
}
/**
* 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
@@ -371,18 +369,18 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// specify the file plan
NodeRef anotherFilePlan = generateNodeRef(TYPE_FILE_PLAN);
versionProperties.put(RecordableVersionServiceImpl.KEY_FILE_PLAN, anotherFilePlan);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(anotherFilePlan);
verifyRecordedVersion(anotherFilePlan);
}
@Test
public void adHocRecordedVersionNoPolicy() throws Exception
{
@@ -390,14 +388,14 @@ public class RecordableVersionServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(filePlan);
verifyRecordedVersion(filePlan);
}
@Test
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);
versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
// when version is created
recordableVersionService.createVersion(nodeRef, versionProperties);
// then the recorded version is created
verifyRecordedVersion(filePlan);
verifyRecordedVersion(filePlan);
}
}