Merge branch 'feature-2.3/RM-2368_Initial_version_record_does_not_inherit_document' into release/V2.3

rm-server/config/alfresco/module/org_alfresco_module_rm/alfresco-global.properties

@@ -77,3 +77,10 @@ rm.patch.v22.convertToStandardFilePlan=false
 # a document will be auto-versioned when its type is changed.
 #
 version.store.enableAutoVersionOnTypeChange=false
+
+#
+# Enable auto-version to be created when there is a difference between the document and latest record state
+# to ensure that the created version record matches the current document state, 
+# otherwise create the version record from the version history
+#
+rm.enableAutoVersionOnRecordCreation=false

rm-server/config/alfresco/module/org_alfresco_module_rm/messages/records-management-service.properties

@@ -19,3 +19,4 @@ rm.service.close-record-folder-not-folder=The record folder couldn't be closed b
 rm.service.node-has-aspect=The node {0} has already the aspect {1}.
 rm.service.final-version=Final
 rm.service.final-version-description=The final archived record version
+rm.service.enable-autoversion-on-record-creation=Auto Version on Record Creation

rm-server/config/alfresco/module/org_alfresco_module_rm/rm-version-context.xml

@@ -21,6 +21,7 @@
    <!-- extended version service bean definition -->
    <bean id="rm.versionService" abstract="true" class="org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionServiceImpl">
       <property name="filePlanService" ref="FilePlanService" />
+      <property name="enableAutoVersionOnRecordCreation" value="${rm.enableAutoVersionOnRecordCreation}" /> 
       <property name="authenticationUtil" ref="rm.authenticationUtil" />
       <property name="relationshipService" ref="RelationshipService" />
       <property name="recordService" ref="RecordService" />
@@ -28,6 +29,7 @@
       <property name="cmObjectType" ref="cm.object" />
       <property name="extendedPermissionService" ref="ExtendedPermissionService" />
       <property name="extendedSecurityService" ref="ExtendedSecurityService" />
+      
    </bean>
    <bean class="org.alfresco.util.BeanExtender">
       <property name="beanName" value="versionService" />
@@ -77,6 +79,7 @@
          <value>
             <![CDATA[
             org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService.isCurrentVersionRecorded=RM_ALLOW
+            org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService.isEnableAutoVersionOnRecordCreation=RM_ALLOW
             org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService.isRecordedVersion=RM_ALLOW
             org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService.getVersionRecord=RM_ALLOW
             org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService.getRecordedVersion=RM_ALLOW

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/record/RecordServiceImpl.java

@@ -1038,6 +1038,8 @@ public class RecordServiceImpl extends BaseBehaviourBean
     {
         NodeRef versionRecord = null;
        
+ 
+        recordableVersionService.createSnapshotVersion(nodeRef);
         // wire record up to previous record
         VersionHistory versionHistory = versionService.getVersionHistory(nodeRef);
         if (versionHistory != null)

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/version/RecordableVersionService.java

@@ -48,8 +48,7 @@ public interface RecordableVersionService
     boolean isRecordedVersion(Version version);
 
     /**
-     * If the version is a recorded version, gets the related version 
-     * record.
+     * If the version is a recorded version, gets the related version record.
      * 
      * @param version version
      * @return NodeRef node reference of version record
@@ -65,16 +64,28 @@ public interface RecordableVersionService
     Version getRecordedVersion(NodeRef record);
 
     /**
-     * Creates a record from the latest version, marking it as recorded.
+     * Creates a record from the latest frozen version, marking it as recorded.
      * <p>
-     * Does not create a record if the node is not versionable or the latest
-     * version is already recorded.
+     * Does not create a record if the node is not versionable or the latest version is already recorded.
      * 
      * @param nodeRef node reference
      * @return NodeRef node reference to the created record.
      */
     NodeRef createRecordFromLatestVersion(NodeRef filePlan, NodeRef nodeRef);
    
+    /**
+     * Creates a record from the latest version, marking it as recorded.
+     * <p>
+     * Does not create a record if the node is not versionable or the latest version is already recorded.
+     * 
+     * @param nodeRef parent node reference
+     * @param nodeRef node reference
+     * @param autoVersion true, create new record version from latest version, false creates a record from the latest frozen version
+     * @return NodeRef node reference to the created record.
+     * 
+     */
+    NodeRef createRecordFromLatestVersion(NodeRef filePlan, NodeRef nodeRef, boolean autoVersion);
+
     /**
      * Indicates whether a record version is destroyed or not.
      * 
@@ -86,11 +97,23 @@ public interface RecordableVersionService
     /**
      * Marks a recorded version as destroyed.
      * <p>
-     * Note this method does not destroy the associated record, instead it marks the 
-     * version as destroyed.
+     * Note this method does not destroy the associated record, instead it marks the version as destroyed.
      * 
      * @param version version
      */
     void destroyRecordedVersion(Version version);
 
+    /**
+     * Flag that indicate to create new version on record creation if current node is modified
+     * 
+     * @return boolean true to auto-version on record creation, false to use latest versioned version
+     */
+    boolean isEnableAutoVersionOnRecordCreation();
+
+    /**
+     * Create a snapshot version of current node
+     * 
+     * @param nodeRef node reference
+     */
+    void createSnapshotVersion(NodeRef nodeRef);
 }

rm-server/source/java/org/alfresco/module/org_alfresco_module_rm/version/RecordableVersionServiceImpl.java

@@ -24,6 +24,7 @@ import static org.codehaus.plexus.util.StringUtils.isNotBlank;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
@@ -57,6 +58,7 @@ import org.alfresco.util.PropertyMap;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.springframework.extensions.surf.util.I18NUtil;
 
 /**
  * Recordable version service implementation
@@ -79,6 +81,12 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
     protected static final String PROP_VERSION_RECORD = "RecordVersion";
     protected static final String PROP_RECORDED_VERSION_DESTROYED = "RecordedVersionDestroyed";
     
+    /** I18N */
+    private static final String AUTO_VERSION_ON_RECORD_CREATION = "rm.service.enable-autoversion-on-record-creation";
+
+    /** flag that enable auto-version on record creation */
+    private boolean isEnableAutoVersionOnRecordCreation = false;
+
     /** version aspect property names */
     private static final String[] VERSION_PROPERTY_NAMES = new String[]
     {
@@ -185,7 +193,21 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
     }
 
     /**
-     * @see org.alfresco.repo.version.Version2ServiceImpl#createVersion(org.alfresco.service.cmr.repository.NodeRef, java.util.Map, int)
+     * @param isEnableAutoVersionOnRecordCreation
+     */
+    public void setEnableAutoVersionOnRecordCreation(boolean isEnableAutoVersionOnRecordCreation)
+    {
+        this.isEnableAutoVersionOnRecordCreation = isEnableAutoVersionOnRecordCreation;
+    }
+
+    public boolean isEnableAutoVersionOnRecordCreation()
+    {
+        return isEnableAutoVersionOnRecordCreation;
+    }
+
+    /**
+     * @see org.alfresco.repo.version.Version2ServiceImpl#createVersion(org.alfresco.service.cmr.repository.NodeRef,
+     *      java.util.Map, int)
      */
     @Override
     protected Version createVersion(NodeRef nodeRef, Map<String, Serializable> origVersionProperties, int versionNumber) throws ReservedVersionNameException
@@ -205,7 +227,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
             VersionType versionType = null;
             if (origVersionProperties != null)
             {
-                versionType = (VersionType)origVersionProperties.get(VersionModel.PROP_VERSION_TYPE);
+                versionType = (VersionType) origVersionProperties.get(VersionModel.PROP_VERSION_TYPE);
             }
 
             // determine whether this is a recorded version or not
@@ -237,7 +259,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
      */
     private NodeRef getFilePlan(NodeRef nodeRef)
     {
-        NodeRef filePlan = (NodeRef)nodeService.getProperty(nodeRef, PROP_FILE_PLAN);
+        NodeRef filePlan = (NodeRef) nodeService.getProperty(nodeRef, PROP_FILE_PLAN);
         if (filePlan == null)
         {
             filePlan = getFilePlan();
@@ -276,7 +298,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         boolean result = false;
         if (nodeService.hasAspect(nodeRef, RecordableVersionModel.ASPECT_VERSIONABLE))
         {
-            String policyString = (String)nodeService.getProperty(nodeRef, PROP_RECORDABLE_VERSION_POLICY);
+            String policyString = (String) nodeService.getProperty(nodeRef, PROP_RECORDABLE_VERSION_POLICY);
             if (policyString != null)
             {
                 RecordableVersionPolicy policy = RecordableVersionPolicy.valueOf(policyString.toUpperCase());
@@ -356,14 +378,14 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         try
         {
             // get the destination file plan
-            final NodeRef filePlan = (NodeRef)versionProperties.get(KEY_FILE_PLAN);
+            final NodeRef filePlan = (NodeRef) versionProperties.get(KEY_FILE_PLAN);
             if (filePlan == null)
             {
                 throw new AlfrescoRuntimeException("Can't create a new recorded version, because no file plan has been specified in the version properties.");
             }
 
             // create a copy of the source node and place in the file plan
-            final NodeRef nodeRef = (NodeRef)standardVersionProperties.get(Version2Model.PROP_QNAME_FROZEN_NODE_REF);
+            final NodeRef nodeRef = (NodeRef) standardVersionProperties.get(Version2Model.PROP_QNAME_FROZEN_NODE_REF);
 
             cmObjectType.disableCopy();
             try
@@ -400,7 +422,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
                 nodeService.addAspect(versionNodeRef, Version2Model.ASPECT_VERSION, standardVersionProperties);
 
                 // add the recordedVersion aspect with link to record
-                nodeService.addAspect(versionNodeRef, ASPECT_RECORDED_VERSION, Collections.singletonMap(PROP_RECORD_NODE_REF, (Serializable)record));
+                nodeService.addAspect(versionNodeRef, ASPECT_RECORDED_VERSION, Collections.singletonMap(PROP_RECORD_NODE_REF, (Serializable) record));
 
                 // freeze auditable aspect information
                 freezeAuditableAspect(nodeRef, versionNodeRef);
@@ -480,7 +502,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
             for (Version previousVersion : previousVersions)
             {
                 // look for the associated record
-                final NodeRef previousRecord = (NodeRef)previousVersion.getVersionProperties().get(PROP_VERSION_RECORD);
+                final NodeRef previousRecord = (NodeRef) previousVersion.getVersionProperties().get(PROP_VERSION_RECORD);
                 if (previousRecord != null &&
                     nodeService.exists(previousRecord))
                 {
@@ -545,17 +567,18 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
     @Override
     protected Version getVersion(NodeRef versionRef)
     {
+
         Version version = super.getVersion(versionRef);
 
         // place the version record reference in the version properties
-        NodeRef record = (NodeRef)dbNodeService.getProperty(versionRef, PROP_RECORD_NODE_REF);
+        NodeRef record = (NodeRef) dbNodeService.getProperty(versionRef, PROP_RECORD_NODE_REF);
         if (record != null)
         {
             version.getVersionProperties().put(PROP_VERSION_RECORD, record);
         }
 
         // place information about the destruction of the version record in the properties
-        Boolean destroyed = (Boolean)dbNodeService.getProperty(versionRef, PROP_DESTROYED);
+        Boolean destroyed = (Boolean) dbNodeService.getProperty(versionRef, PROP_DESTROYED);
         if (destroyed == null) { destroyed = Boolean.FALSE; }
         version.getVersionProperties().put(PROP_RECORDED_VERSION_DESTROYED, destroyed);
 
@@ -614,7 +637,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         if (dbNodeService.hasAspect(versionNodeRef, RecordableVersionModel.ASPECT_RECORDED_VERSION))
         {
             // get the version record
-            result = (NodeRef)dbNodeService.getProperty(versionNodeRef, RecordableVersionModel.PROP_RECORD_NODE_REF);
+            result = (NodeRef) dbNodeService.getProperty(versionNodeRef, RecordableVersionModel.PROP_RECORD_NODE_REF);
 
             // check that the version record exists
             if (result != null && 
@@ -651,6 +674,17 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         return new NodeRef(convertStoreRef(nodeRef.getStoreRef()), nodeRef.getId());
     }
     
+    /**
+     * @see org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService#createRecordFromLatestVersion(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.repository.NodeRef, autoVersion)
+     */
+    @Override
+    public NodeRef createRecordFromLatestVersion(final NodeRef filePlan, final NodeRef nodeRef, final boolean isEnableAutoVersionOnRecordCreation)
+    {
+        setEnableAutoVersionOnRecordCreation(isEnableAutoVersionOnRecordCreation);
+        
+        return createRecordFromLatestVersion(filePlan, nodeRef);
+    }
+
     /**
      * @see org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService#createRecordFromLatestVersion(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.repository.NodeRef)
      */
@@ -665,6 +699,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         // check for versionable aspect
         if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE))
         {
+            createSnapshotVersion(nodeRef);
             // get the latest version
             final Version currentVersion = getCurrentVersion(nodeRef);
 
@@ -732,7 +767,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
                 QName sourceTypeRef = getVersionType(currentVersion);
 
                 // patch-up owner information, which needs to be frozen for recorded versions
-                String owner = (String)nodeService.getProperty(currentVersion.getFrozenStateNodeRef(), ContentModel.PROP_OWNER);
+                String owner = (String) nodeService.getProperty(currentVersion.getFrozenStateNodeRef(), ContentModel.PROP_OWNER);
                 if (owner != null)
                 {
                     versionProperties.put(PROP_FROZEN_OWNER, owner);
@@ -760,7 +795,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
                 nodeService.addAspect(versionNodeRef, Version2Model.ASPECT_VERSION, versionProperties);
 
                 // add the recordedVersion aspect with link to record
-                nodeService.addAspect(versionNodeRef, ASPECT_RECORDED_VERSION, Collections.singletonMap(PROP_RECORD_NODE_REF, (Serializable)record));
+                nodeService.addAspect(versionNodeRef, ASPECT_RECORDED_VERSION, Collections.singletonMap(PROP_RECORD_NODE_REF, (Serializable) record));
             }
         }
 
@@ -779,7 +814,7 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
         NodeRef versionNodeRef = getVersionNodeRef(version);
 
         // get the destroyed property value
-        Boolean isDestroyed = (Boolean)dbNodeService.getProperty(versionNodeRef, PROP_DESTROYED);
+        Boolean isDestroyed = (Boolean) dbNodeService.getProperty(versionNodeRef, PROP_DESTROYED);
         if (isDestroyed != null)
         {
             result = isDestroyed.booleanValue();
@@ -869,4 +904,45 @@ public class RecordableVersionServiceImpl extends    Version2ServiceImpl
     {
         return convertNodeRef(version.getFrozenStateNodeRef());
     }
+
+    /**
+     * Check if current version of the node is modified compared with versioned version
+     * 
+     * @param nodeRef internal node reference
+     * @return boolean true if nodeRef is modified, otherwise false
+     */
+    public boolean isCurrentVersionDirty(NodeRef nodeRef)
+    {
+        if (!nodeService.hasAspect(nodeRef, ContentModel.ASPECT_VERSIONABLE)) { return false; }
+
+        // get the latest version
+        Version currentVersion = getCurrentVersion(nodeRef);
+        Date modificationDate = (Date) nodeService.getProperty(nodeRef, ContentModel.PROP_MODIFIED);
+
+        if (currentVersion == null) { return true; }
+
+        // grab the frozen state
+        NodeRef currentFrozenState = currentVersion.getFrozenStateNodeRef();
+        Date frozenModificationDate = (Date) nodeService.getProperty(currentFrozenState, ContentModel.PROP_MODIFIED);
+
+        boolean versionStoreOutdated = ((frozenModificationDate != null) && (modificationDate.getTime() > frozenModificationDate.getTime()));
+        return versionStoreOutdated;
+    }
+
+    /**
+     * @see RecordableVersionService#createSnapshotVersion(NodeRef)
+     */
+    public void createSnapshotVersion(NodeRef nodeRef)
+    {
+        boolean autoVersion = isEnableAutoVersionOnRecordCreation();
+        // if the flag autoversion on record creation set, create new version on dirty nodes
+        if (autoVersion && isCurrentVersionDirty(nodeRef))
+        {
+            Map<String, Serializable> autoVersionProperties = new HashMap<String, Serializable>(2);
+            autoVersionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MINOR);
+            autoVersionProperties.put(VersionModel.PROP_DESCRIPTION, I18NUtil.getMessage(AUTO_VERSION_ON_RECORD_CREATION));
+            createVersion(nodeRef, autoVersionProperties);
+        }
+
+    }
 }

rm-server/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/version/DeclareAsRecordVersionTest.java

@@ -19,15 +19,18 @@
 package org.alfresco.module.org_alfresco_module_rm.test.integration.version;
 
 import java.io.Serializable;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.alfresco.model.ContentModel;
 import org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionService;
 import org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionServiceImpl;
 import org.alfresco.repo.version.VersionModel;
 import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.version.Version;
 import org.alfresco.service.cmr.version.VersionType;
+import org.alfresco.service.namespace.QName;
 import org.alfresco.util.GUID;
 
 /**
@@ -48,7 +51,7 @@ public class DeclareAsRecordVersionTest extends RecordableVersionsBaseTest
     protected void initServices()
     {
         super.initServices();
-        recordableVersionService = (RecordableVersionService)applicationContext.getBean("RecordableVersionService");
+        recordableVersionService = (RecordableVersionService) applicationContext.getBean("RecordableVersionService");
     }
 
     /**
@@ -205,4 +208,184 @@ public class DeclareAsRecordVersionTest extends RecordableVersionsBaseTest
 
     }
 
+    /**
+     * Given versionable content with a recorded latest version and autoversion is true
+     * When I declare this version record and contains local modifications 
+     * Then a new minor version is created for document 
+     * 
+     * @see https://issues.alfresco.com/jira/browse/RM-2368
+     */
+    public void testCreateRecordFromLatestVersionAutoTrue()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest(dmCollaborator)
+        {
+            private NodeRef myDocument;
+            private NodeRef versionedRecord;
+            private Map<String, Serializable> versionProperties;
+            private Date createdDate;
+            private Date modificationDate;
+            private String record_name = "initial_name";
+            private String AUTO_VERSION_DESCRIPTION = "Auto Version on Record Creation";
+            private boolean autoVersion = true;
+
+            public void given() throws Exception
+            {
+                // create a document
+                myDocument = fileFolderService.create(dmFolder, GUID.generate(), ContentModel.TYPE_CONTENT).getNodeRef();
+                createdDate = (Date) nodeService.getProperty(myDocument, ContentModel.PROP_CREATED);
+                modificationDate = (Date) nodeService.getProperty(myDocument, ContentModel.PROP_MODIFIED);
+                assertTrue("Modified date must be after or on creation date", createdDate.getTime() == modificationDate.getTime());
+
+                // Set initial set of properties
+                Map<QName, Serializable> properties = new HashMap<QName, Serializable>(3);
+                // Ensure default behaviour autoversion on change properties is set to false
+                properties.put(ContentModel.PROP_AUTO_VERSION_PROPS, false);
+                // Set initial name
+                properties.put(ContentModel.PROP_NAME, "initial_name");
+                nodeService.setProperties(myDocument, properties);
+                nodeService.setProperty(myDocument, ContentModel.PROP_DESCRIPTION, DESCRIPTION);
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_OWNABLE, null);
+                // make sure document is versionable
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_VERSIONABLE, null);
+                // Change Type to a custom document
+                nodeService.setType(myDocument, TYPE_CUSTOM_TYPE);
+
+                // setup version properties
+                versionProperties = new HashMap<String, Serializable>(2);
+                versionProperties.put(Version.PROP_DESCRIPTION, DESCRIPTION);
+                versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
+
+                // create initial version
+                versionService.createVersion(myDocument, versionProperties);
+            }
+
+            public void when()
+            {
+                // Apply a custom aspect
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_TITLED, null);
+                // Update properties
+                nodeService.setProperty(myDocument, ContentModel.PROP_NAME, "updated_name");
+                nodeService.setProperty(myDocument, ContentModel.PROP_DESCRIPTION, DESCRIPTION);
+                // test RM-2368
+                versionedRecord = recordableVersionService.createRecordFromLatestVersion(filePlan, myDocument, autoVersion);
+            }
+
+            public void then()
+            {
+                // Properties updated / flag as modified
+                // check the created record
+                assertNotNull(versionedRecord);
+                assertTrue(recordService.isRecord(versionedRecord));
+
+                // check the record type is correct
+                assertEquals(TYPE_CUSTOM_TYPE, nodeService.getType(versionedRecord));
+
+                // assert the current version is recorded
+                assertTrue(recordableVersionService.isCurrentVersionRecorded(myDocument));
+
+                // get name of record
+                record_name = (String) nodeService.getProperty(versionedRecord, ContentModel.PROP_NAME);
+
+                // new version is create, current node was modified
+                assertTrue("Name was updated:", record_name.contains("updated_name"));
+                // check record
+                checkRecordedVersion(myDocument, AUTO_VERSION_DESCRIPTION, "1.1");
+
+            }
+
+        });
+
+    }
+    
+    
+    /**
+     * 
+     * Given versionable content with a recorded latest version and autoversion is false
+     * When I declare this version record and contains local modifications 
+     * Then a record is created from latest version
+     *
+     * @see https://issues.alfresco.com/jira/browse/RM-2368
+     */
+    public void testCreateRecordFromLatestVersion()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest(dmCollaborator)
+        {
+            private NodeRef myDocument;
+            private NodeRef versionedRecord;
+            private Map<String, Serializable> versionProperties;
+            private Date createdDate;
+            private Date modificationDate;
+            private String record_name = "initial_name";
+            private boolean autoVersion = false;
+
+            public void given() throws Exception
+            {
+                // create a document
+                myDocument = fileFolderService.create(dmFolder, GUID.generate(), ContentModel.TYPE_CONTENT).getNodeRef();
+                createdDate = (Date) nodeService.getProperty(myDocument, ContentModel.PROP_CREATED);
+                modificationDate = (Date) nodeService.getProperty(myDocument, ContentModel.PROP_MODIFIED);
+                assertTrue("Modified date must be after or on creation date", createdDate.getTime() == modificationDate.getTime());
+
+                // Set initial set of properties
+                Map<QName, Serializable> properties = new HashMap<QName, Serializable>(3);
+                // Ensure default behaviour autoversion on change properties is set to false
+                properties.put(ContentModel.PROP_AUTO_VERSION_PROPS, false);
+                // Set initial name
+                properties.put(ContentModel.PROP_NAME, "initial_name");
+                nodeService.setProperties(myDocument, properties);
+                nodeService.setProperty(myDocument, ContentModel.PROP_DESCRIPTION, DESCRIPTION);
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_OWNABLE, null);
+                // make sure document is versionable
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_VERSIONABLE, null);
+                // Change Type to a custom document
+                nodeService.setType(myDocument, TYPE_CUSTOM_TYPE);
+
+                // setup version properties
+                versionProperties = new HashMap<String, Serializable>(2);
+                versionProperties.put(Version.PROP_DESCRIPTION, DESCRIPTION);
+                versionProperties.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
+
+                // create initial version
+                versionService.createVersion(myDocument, versionProperties);
+            }
+
+            public void when()
+            {
+                // Apply a custom aspect
+                nodeService.addAspect(myDocument, ContentModel.ASPECT_TITLED, null);
+                // Update properties
+                nodeService.setProperty(myDocument, ContentModel.PROP_NAME, "initial_name");
+                nodeService.setProperty(myDocument, ContentModel.PROP_DESCRIPTION, DESCRIPTION);
+                // test RM-2368
+                versionedRecord = recordableVersionService.createRecordFromLatestVersion(filePlan, myDocument, autoVersion);
+            }
+
+            public void then()
+            {
+                // Properties updated / flag as modified
+                // check the created record
+                assertNotNull(versionedRecord);
+                assertTrue(recordService.isRecord(versionedRecord));
+
+                // check the record type is correct
+                assertEquals(TYPE_CUSTOM_TYPE, nodeService.getType(versionedRecord));
+
+                // assert the current version is recorded
+                assertTrue(recordableVersionService.isCurrentVersionRecorded(myDocument));
+
+                // get name of record
+                record_name = (String) nodeService.getProperty(versionedRecord, ContentModel.PROP_NAME);
+
+                // record is created based on existing frozen, which does not contain any modification of node
+                assertTrue("Name is not modified: ", record_name.contains("initial_name"));
+                checkRecordedVersion(myDocument, DESCRIPTION, "1.0");
+ 
+            }
+ 
+
+        });
+
+    }
+
+
 }