RM-1635: Recordable Version Store Service Prototype (WIP)

* extended version service implementation that can use the file plan as an alternative version store, thus recording versions
  * extended version node service implementation that can retrieve recorded version information from the file plan (rather than the version frozen state) (properties only atm)
  * recordable version model including recorded version information and versionable aspect extension with auto recordable version policy defined
  * Recordable version service unit tests
  * Simple AdHoc recorded version integration test (shows recorded created and frozen property state recovered via file plan record)



git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/modules/recordsmanagement/HEAD@80223 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/action/impl/FileReportActionUnitTest.java

@@ -51,7 +51,7 @@ public class FileReportActionUnitTest extends BaseUnitTest
      * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest#before()
      */
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
 

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/capability/declarative/condition/HoldCapabilityConditionUnitTest.java

@@ -67,7 +67,7 @@ public class HoldCapabilityConditionUnitTest extends BaseUnitTest
      */
     @Before
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/hold/HoldServiceImplUnitTest.java

@@ -77,7 +77,7 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
 
     @Before
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
 

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/job/DispositionLifecycleJobExecuterUnitTest.java

@@ -72,7 +72,7 @@ public class DispositionLifecycleJobExecuterUnitTest extends BaseUnitTest
      */
     @Override
     @Before
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/jscript/app/evaluator/FrozenEvaluatorUnitTest.java

@@ -50,7 +50,7 @@ public class FrozenEvaluatorUnitTest extends BaseUnitTest
     
     @Before
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/jscript/app/evaluator/TransferEvaluatorUnitTest.java

@@ -51,7 +51,7 @@ public class TransferEvaluatorUnitTest extends BaseUnitTest
     @Spy @InjectMocks TransferEvaluator transferEvaluator;
     
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/record/RecordServiceImplUnitTest.java

@@ -55,7 +55,7 @@ public class RecordServiceImplUnitTest extends BaseUnitTest
     @SuppressWarnings("unchecked")
     @Before
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/script/hold/BaseHoldWebScriptUnitTest.java

@@ -27,7 +27,7 @@ public abstract class BaseHoldWebScriptUnitTest extends BaseWebScriptUnitTest
      * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest#before()
      */
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
 

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/security/FilePlanPermissionServiceImplUnitTest.java

@@ -83,7 +83,7 @@ public class FilePlanPermissionServiceImplUnitTest extends BaseUnitTest
      * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest#before()
      */
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/test/AllUnitTestSuite.java

@@ -32,7 +32,9 @@ import org.alfresco.module.org_alfresco_module_rm.record.RecordServiceImplUnitTe
 import org.alfresco.module.org_alfresco_module_rm.script.hold.HoldPostUnitTest;
 import org.alfresco.module.org_alfresco_module_rm.script.hold.HoldPutUnitTest;
 import org.alfresco.module.org_alfresco_module_rm.script.hold.HoldsGetUnitTest;
+import org.alfresco.module.org_alfresco_module_rm.security.FilePlanPermissionServiceImplUnitTest;
 import org.alfresco.module.org_alfresco_module_rm.util.BeanExtenderUnitTest;
+import org.alfresco.module.org_alfresco_module_rm.version.RecordableVersionServiceImplUnitTest;
 import org.alfresco.repo.action.parameter.DateParameterProcessorUnitTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
@@ -57,7 +59,8 @@ import org.junit.runners.Suite.SuiteClasses;
     // services
     RecordServiceImplUnitTest.class,
     HoldServiceImplUnitTest.class,
-    //FilePlanPermissionServiceImplUnitTest.class,
+    FilePlanPermissionServiceImplUnitTest.class,
+    RecordableVersionServiceImplUnitTest.class,
     
     // evaluators
     TransferEvaluatorUnitTest.class,

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/test/util/BaseUnitTest.java

@@ -23,6 +23,7 @@ import static org.mockito.Matchers.anyString;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
@@ -41,11 +42,15 @@ import org.alfresco.module.org_alfresco_module_rm.recordfolder.RecordFolderServi
 import org.alfresco.module.org_alfresco_module_rm.report.ReportService;
 import org.alfresco.module.org_alfresco_module_rm.role.FilePlanRoleService;
 import org.alfresco.module.org_alfresco_module_rm.util.ServiceBaseImpl;
+import org.alfresco.repo.policy.BehaviourFilter;
+import org.alfresco.repo.policy.PolicyComponent;
 import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
 import org.alfresco.repo.transaction.RetryingTransactionHelper;
 import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
 import org.alfresco.service.cmr.dictionary.DictionaryService;
+import org.alfresco.service.cmr.model.FileFolderService;
 import org.alfresco.service.cmr.repository.ChildAssociationRef;
+import org.alfresco.service.cmr.repository.CopyService;
 import org.alfresco.service.cmr.repository.NodeRef;
 import org.alfresco.service.cmr.repository.NodeService;
 import org.alfresco.service.cmr.repository.StoreRef;
@@ -77,7 +82,7 @@ import org.springframework.context.ApplicationContext;
  * @author Roy Wetherall
  * @since 2.2
  */
-public class BaseUnitTest implements RecordsManagementModel
+public class BaseUnitTest implements RecordsManagementModel, ContentModel
 {
     protected NodeRef filePlanComponent;
     protected NodeRef filePlan;
@@ -95,6 +100,9 @@ public class BaseUnitTest implements RecordsManagementModel
     @Mock(name="searchService")                  protected SearchService                mockedSearchService;
     @Mock(name="retryingTransactionHelper")      protected RetryingTransactionHelper    mockedRetryingTransactionHelper;
     @Mock(name="authorityService")               protected AuthorityService             mockedAuthorityService;
+    @Mock(name="policyComponent")                protected PolicyComponent              mockedPolicyComponent; 
+    @Mock(name="copyService")                    protected CopyService                  mockedCopyService;
+    @Mock(name="fileFolderService")              protected FileFolderService            mockedFileFolderService;
     
     /** rm service mocks */
     @Mock(name="filePlanService")                protected FilePlanService              mockedFilePlanService;
@@ -105,6 +113,7 @@ public class BaseUnitTest implements RecordsManagementModel
     @Mock(name="reportService")                  protected ReportService                mockedReportService;
     @Mock(name="filePlanRoleService")            protected FilePlanRoleService          mockedFilePlanRoleService;
     @Mock(name="recordsManagementAuditService")  protected RecordsManagementAuditService mockedRecordsManagementAuditService;
+    @Mock(name="policyBehaviourFilter")          protected BehaviourFilter              mockedBehaviourFilter;
     
     /** application context mock */
     @Mock(name="applicationContext")             protected ApplicationContext           mockedApplicationContext;
@@ -118,7 +127,7 @@ public class BaseUnitTest implements RecordsManagementModel
      */
     @SuppressWarnings("unchecked")
     @Before
-    public void before()
+    public void before() throws Exception
     {
         MockitoAnnotations.initMocks(this);
         
@@ -161,7 +170,7 @@ public class BaseUnitTest implements RecordsManagementModel
         doReturn(result).when(mockedNodeService).getChildAssocs(eq(recordFolder), eq(ContentModel.ASSOC_CONTAINS), any(QNamePattern.class));
         doReturn(result).when(mockedNodeService).getParentAssocs(record);
         doReturn(Collections.singletonList(recordFolder)).when(mockedRecordFolderService).getRecordFolders(record);
-        doReturn(Collections.singletonList(record)).when(mockedRecordService).getRecords(recordFolder);        
+        doReturn(Collections.singletonList(record)).when(mockedRecordService).getRecords(recordFolder);      
     }
     
     /**
@@ -250,6 +259,19 @@ public class BaseUnitTest implements RecordsManagementModel
         return generateNodeRef(type, true);
     }
     
+    /**
+     * Helper method to generate a cm:content node reference with a given name.
+     * 
+     * @param name      content name
+     * @return NodeRef  node reference
+     */
+    protected NodeRef generateCmContent(String name)
+    {
+        NodeRef nodeRef = generateNodeRef(ContentModel.TYPE_CONTENT, true);
+        doReturn(name).when(mockedNodeService).getProperty(nodeRef, ContentModel.PROP_NAME);
+        return nodeRef;
+    }
+    
     /**
      * Helper method to generate a node reference of a particular type with a given existence characteristic.
      * 
@@ -268,6 +290,30 @@ public class BaseUnitTest implements RecordsManagementModel
         }
         return nodeRef;
     }
+
+    /**
+     * Helper method to generate a mocked child association reference.
+     * 
+     * @param parent                        parent node (optional)
+     * @param child                         child node (optional)
+     * @return {@link ChildAssociationRef}  mocked to return the parent and child nodes
+     */
+    protected ChildAssociationRef generateChildAssociationRef(NodeRef parent, NodeRef child)
+    {
+        ChildAssociationRef mockedChildAssociationRef = mock(ChildAssociationRef.class);
+        
+        if (parent != null)
+        {
+            doReturn(parent).when(mockedChildAssociationRef).getParentRef();
+        }
+        
+        if (child != null)
+        {
+            doReturn(child).when(mockedChildAssociationRef).getChildRef();
+        }
+        
+        return mockedChildAssociationRef;
+    }
     
     /**
      * Helper method to make one node the primary parent of the other.

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/util/BeanExtenderUnitTest.java

@@ -61,7 +61,7 @@ public class BeanExtenderUnitTest extends BaseUnitTest
     @InjectMocks private BeanExtender beanExtender;
     
     @Override
-    public void before()
+    public void before() throws Exception
     {
         super.before();
         

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

@@ -0,0 +1,416 @@
+/*
+ * Copyright (C) 2005-2014 Alfresco Software Limited.
+ *
+ * This file is part of Alfresco
+ *
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+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.eq;
+import static org.mockito.Mockito.doReturn;
+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;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.alfresco.error.AlfrescoRuntimeException;
+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;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.cmr.version.VersionType;
+import org.alfresco.service.namespace.QName;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+/**
+ * Recordable version service implementation unit test.
+ * 
+ * @author Roy Wetherall
+ * @since 2.3
+ */
+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;
+
+    /**
+     * @see org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest#before()
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public void before() throws Exception
+    {
+        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),
+                                                  any(QName.class),
+                                                  eq(Version2Model.TYPE_QNAME_VERSION_HISTORY),
+                                                  anyMap());
+        doReturn(generateChildAssociationRef(null, generateNodeRef(TYPE_CONTENT)))
+        .when(mockedDbNodeService).createNode(any(NodeRef.class),
+                                              any(QName.class),
+                                              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), 
+                                                                    any(String.class));
+        version = generateNodeRef(TYPE_CONTENT);
+        doReturn(generateChildAssociationRef(null, version)).when(mockedDbNodeService).createNode(
+                                                                any(NodeRef.class), 
+                                                                eq(Version2Model.CHILD_QNAME_VERSIONS),
+                                                                any(QName.class), 
+                                                                eq(TYPE_CONTENT), 
+                                                                anyMap());
+    }
+    
+    /**
+     * Given that the node has no recordable version aspect 
+     * When I create a version 
+     * Then version service creates a normal version.
+     */
+    @Test
+    public void noAspect() throws Exception
+    {
+        // 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 
+     * Then the version service creates a normal version.
+     */
+     @Test
+     public void policyNull() throws Exception
+     {
+         // setup given conditions
+         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 
+     * Then the version service creates a normal version.
+     */
+    @Test
+    public void policyNone() throws Exception
+    {
+        // setup given conditions
+        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 
+     * the version service creates a recorded version
+     */
+    @Test
+    public void policyAllVersionMinor() throws Exception
+    {
+        // setup given conditions
+        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.
+     */
+    @SuppressWarnings("unchecked")
+    private void verifyRecordedVersion(NodeRef filePlan) throws Exception
+    {
+        // 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), 
+                                                       anyString());
+        
+        // then the version is created
+        verify(mockedDbNodeService, times(1)).createNode(any(NodeRef.class), 
+                                                         eq(Version2Model.CHILD_QNAME_VERSIONS),
+                                                         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), 
+                                                                   eq(Collections.singletonMap(RecordableVersionModel.PROP_RECORD_NODE_REF, (Serializable)record)));
+    }
+    
+    /**
+     * Helper method that verified that a recorded version was not created.
+     */
+    @SuppressWarnings("unchecked")
+    private void verifyNormalVersion() throws Exception
+    {
+        // verify no interactions
+        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), 
+                                                         eq(Version2Model.CHILD_QNAME_VERSIONS),
+                                                         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 
+     * the version service creates a recorded version
+     */
+    @Test
+    public void policyAllVersionMajor() throws Exception
+    {
+        // setup given conditions
+        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 
+     * the version service creates a normal version
+     */
+    @Test
+    public void policyMajorOnlyVersionMinor() throws Exception
+    {
+        // setup given conditions
+        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 
+     * the version service creates a recorded version
+     */
+    @Test
+    public void policyMajorOnlyVersionMajor() throws Exception
+    {
+        // setup given conditions
+        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
+     * When I create a new version
+     * Then an exception should be thrown to indicate that there is no file plan
+     */
+    @Test
+    public void noFilePlan() throws Exception
+    {
+        // setup given conditions
+        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);
+        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
+     * When I create a new version
+     * Then the recorded version should be directed to the specified file plan, not the default file plan
+     */
+    @Test
+    public void filePlanSpecifiedWithPolicy() throws Exception
+    {
+        // setup given conditions
+        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);        
+    }
+    
+    /**
+     * 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
+     * When I create a new version
+     * Then the recorded version should be directed to the specified file plan, not the default file plan
+     */
+    @Test
+    public void filePlanSpecifiedNoPolicy() throws Exception
+    {
+        // setup given conditions
+        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);        
+    }
+    
+    @Test
+    public void adHocRecordedVersionNoPolicy() throws Exception
+    {
+        // setup given conditions
+        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);         
+    }
+    
+    @Test
+    public void adHocRecordedVersionOverridePolicy() throws Exception
+    {
+        // setup given conditions
+        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);
+        versionProperties.put(RecordableVersionServiceImpl.KEY_RECORDABLE_VERSION, true);
+        
+        // when version is created
+        recordableVersionService.createVersion(nodeRef, versionProperties);
+        
+        // then the recorded version is created
+        verifyRecordedVersion(filePlan);      
+    }
+}

rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/version/TestRecordableVersionServiceImpl.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2005-2014 Alfresco Software Limited.
+ *
+ * This file is part of Alfresco
+ *
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.alfresco.module.org_alfresco_module_rm.version;
+
+import java.io.Serializable;
+import java.util.Map;
+
+import org.alfresco.repo.policy.PolicyScope;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.version.Version;
+import org.alfresco.service.namespace.QName;
+
+/**
+ * Helper class to help with the unit testing of RecordableVersionServiceImpl.
+ * 
+ * @author Roy Wetherall
+ * @since 2.3
+ */
+public class TestRecordableVersionServiceImpl extends RecordableVersionServiceImpl
+{
+    @Override
+    protected void invokeBeforeCreateVersion(NodeRef nodeRef)
+    {
+    }        
+    
+    @Override
+    protected void invokeAfterCreateVersion(NodeRef nodeRef, Version version)
+    {
+    }
+    
+    @Override
+    protected void invokeAfterVersionRevert(NodeRef nodeRef, Version version)
+    {
+    }
+    
+    @Override
+    protected void invokeOnCreateVersion(NodeRef nodeRef, Map<String, Serializable> versionProperties,PolicyScope nodeDetails)
+    {
+    }
+    
+    @Override
+    protected String invokeCalculateVersionLabel(QName classRef, Version preceedingVersion, int versionNumber, Map<String, Serializable> versionProperties)
+    {
+        return "1.1";
+    }
+}