Removed warnings

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

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

@@ -26,12 +26,12 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 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.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.doAnswer;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -42,7 +42,6 @@ import java.util.Map;
 import org.alfresco.error.AlfrescoRuntimeException;
 import org.alfresco.model.ContentModel;
 import org.alfresco.module.org_alfresco_module_rm.BaseUnitTest;
-import org.alfresco.module.org_alfresco_module_rm.fileplan.FilePlanService;
 import org.alfresco.module.org_alfresco_module_rm.record.RecordService;
 import org.alfresco.module.org_alfresco_module_rm.recordfolder.RecordFolderService;
 import org.alfresco.service.cmr.repository.ChildAssociationRef;
@@ -63,7 +62,7 @@ import org.mockito.stubbing.Answer;
 
 /**
  * Hold service implementation unit test
- * 
+ *
  * @author Roy Wetherall
  */
 public class HoldServiceImplUnitTest extends BaseUnitTest
@@ -72,82 +71,82 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
     private static final String HOLD_NAME = "holdname";
     private static final String HOLD_REASON = "holdreason";
     private static final String HOLD_DESCRIPTION = "holddescription";
-    
+
     protected NodeRef holdContainer;
     protected NodeRef hold;
     protected NodeRef hold2;
     protected NodeRef recordFolder;
     protected NodeRef record;
-    
+
     @Mock(name="recordFolderService")   protected RecordFolderService mockedRecordFolderService;
     @Mock(name="recordService")         protected RecordService mockedRecordService;
-    
+
     @Spy @InjectMocks HoldServiceImpl holdService;
-    
+
     @Before
     @Override
     public void before()
     {
         super.before();
-        
+
         // setup objects used in mock interactions
         holdContainer = generateNodeRef(TYPE_HOLD_CONTAINER);
         hold = generateNodeRef(TYPE_HOLD);
         hold2 = generateNodeRef(TYPE_HOLD);
         recordFolder = generateRecordFolder();
         record = generateRecord();
-        
+
         // setup interactions
-        doReturn(holdContainer).when(mockedFilePlanService).getHoldContainer(filePlan);   
+        doReturn(holdContainer).when(mockedFilePlanService).getHoldContainer(filePlan);
-        
+
         // set record as child of record folder
         List<ChildAssociationRef> result = new ArrayList<ChildAssociationRef>(1);
-        result.add(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS, recordFolder, generateQName(), record, true, 1));        
+        result.add(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS, recordFolder, generateQName(), record, true, 1));
         doReturn(result).when(mockedNodeService).getChildAssocs(eq(recordFolder), eq(ContentModel.ASSOC_CONTAINS), any(QNamePattern.class));
-        doReturn(result).when(mockedNodeService).getParentAssocs(record);        
+        doReturn(result).when(mockedNodeService).getParentAssocs(record);
         doReturn(Collections.singletonList(recordFolder)).when(mockedRecordFolderService).getRecordFolders(record);
         doReturn(Collections.singletonList(record)).when(mockedRecordService).getRecords(recordFolder);
     }
-    
+
     @Test
     public void isHold()
     {
         assertTrue(holdService.isHold(hold));
         assertFalse(holdService.isHold(recordFolder));
     }
-    
+
     @Test
     public void getHolds()
     {
-        // with no holds 
+        // with no holds
         List<NodeRef> emptyHoldList = holdService.getHolds(filePlan);
-        verify(mockedNodeService).getChildAssocs(holdContainer, ContentModel.ASSOC_CONTAINS, RegexQNamePattern.MATCH_ALL);        
+        verify(mockedNodeService).getChildAssocs(holdContainer, ContentModel.ASSOC_CONTAINS, RegexQNamePattern.MATCH_ALL);
         assertNotNull(emptyHoldList);
         assertTrue(emptyHoldList.isEmpty());
 
         // setup holds (hold1 and hold 2)
         setupHolds();
-        
+
         // with 2 holds
         List<NodeRef> holdsList = holdService.getHolds(filePlan);
         verify(mockedNodeService, times(2)).getChildAssocs(holdContainer, ContentModel.ASSOC_CONTAINS, RegexQNamePattern.MATCH_ALL);
         assertNotNull(holdsList);
         assertEquals(2, holdsList.size());
-        
+
         // check one of the holds
         NodeRef holdFromList = holdsList.get(0);
-        assertEquals(TYPE_HOLD, mockedNodeService.getType(holdFromList));    
+        assertEquals(TYPE_HOLD, mockedNodeService.getType(holdFromList));
     }
-    
+
     private void setupHolds()
     {
         // set up list of two holds
-        List<ChildAssociationRef> list = new ArrayList<ChildAssociationRef>(2);        
+        List<ChildAssociationRef> list = new ArrayList<ChildAssociationRef>(2);
         list.add(new ChildAssociationRef(generateQName(), holdContainer, generateQName(), hold, true, 1));
-        list.add(new ChildAssociationRef(generateQName(), holdContainer, generateQName(), hold2, true, 2));        
+        list.add(new ChildAssociationRef(generateQName(), holdContainer, generateQName(), hold2, true, 2));
         when(mockedNodeService.getChildAssocs(holdContainer, ContentModel.ASSOC_CONTAINS, RegexQNamePattern.MATCH_ALL)).thenReturn(list);
     }
-    
+
     @Test
     public void heldByNothing()
     {
@@ -159,13 +158,13 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         assertTrue(holdService.heldBy(recordFolder, true).isEmpty());
         List<NodeRef> holds = holdService.heldBy(recordFolder, false);
         assertEquals(2, holds.size());
-        
+
         // check that the record isn't held by anything (record is a child of the record folder)
         assertTrue(holdService.heldBy(record, true).isEmpty());
         holds = holdService.heldBy(record, false);
         assertEquals(2, holds.size());
     }
-    
+
     @Test
     public void heldByMultipleResults()
     {
@@ -174,20 +173,20 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         holds.add(new ChildAssociationRef(ASSOC_FROZEN_RECORDS, hold, ASSOC_FROZEN_RECORDS, recordFolder, true, 1));
         holds.add(new ChildAssociationRef(ASSOC_FROZEN_RECORDS, hold2, ASSOC_FROZEN_RECORDS, recordFolder, true, 2));
         doReturn(holds).when(mockedNodeService).getParentAssocs(recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
-        
+
         // check that both holds are found for record folder
         List<NodeRef> heldByHolds = holdService.heldBy(recordFolder, true);
         assertNotNull(heldByHolds);
         assertEquals(2, heldByHolds.size());
         assertTrue(holdService.heldBy(recordFolder, false).isEmpty());
-        
+
         // check that both holds are found for record (even thou they are one level deep)
         heldByHolds = holdService.heldBy(record, true);
         assertNotNull(heldByHolds);
         assertEquals(2, heldByHolds.size());
         assertTrue(holdService.heldBy(record, false).isEmpty());
     }
-    
+
     @Test (expected=AlfrescoRuntimeException.class)
     public void getHold()
     {
@@ -195,32 +194,32 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         when(mockedNodeService.getChildByName(eq(holdContainer), eq(ContentModel.ASSOC_CONTAINS), anyString())).thenReturn(null)
                                                                                                                .thenReturn(hold)
                                                                                                                .thenReturn(recordFolder);
-        
+
         // no hold
         NodeRef noHold = holdService.getHold(filePlan, "notAHold");
         assertNull(noHold);
-        
+
         // found hold
         NodeRef someHold = holdService.getHold(filePlan, "someHold");
         assertNotNull(someHold);
         assertEquals(TYPE_HOLD, mockedNodeService.getType(someHold));
-        
+
         // ensure runtime exception is thrown
         holdService.getHold(filePlan, "notHold");
     }
-    
+
     @Test (expected=RuntimeException.class)
     public void getHeldNotAHold()
     {
         holdService.getHeld(recordFolder);
     }
-    
+
     @Test
     public void getHeldNoResults()
     {
         assertTrue(holdService.getHeld(hold).isEmpty());
     }
-    
+
     @Test
     public void getHeldWithResults()
     {
@@ -228,12 +227,12 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         List<ChildAssociationRef> holds = new ArrayList<ChildAssociationRef>(1);
         holds.add(new ChildAssociationRef(ASSOC_FROZEN_RECORDS, hold, ASSOC_FROZEN_RECORDS, recordFolder, true, 1));
         doReturn(holds).when(mockedNodeService).getChildAssocs(hold, ASSOC_FROZEN_RECORDS, RegexQNamePattern.MATCH_ALL);
-        
+
         List<NodeRef> list = holdService.getHeld(hold);
         assertEquals(1, list.size());
-        assertEquals(recordFolder, list.get(0));        
+        assertEquals(recordFolder, list.get(0));
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void createHold()
@@ -241,18 +240,18 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         // setup node service interactions
         when(mockedNodeService.createNode(eq(holdContainer), eq(ContentModel.ASSOC_CONTAINS), any(QName.class) , eq(TYPE_HOLD), any(Map.class)))
             .thenReturn(new ChildAssociationRef(ContentModel.ASSOC_CONTAINS, holdContainer, generateQName(), hold));
-        
+
         // create hold
-        NodeRef newHold = holdService.createHold(filePlan, HOLD_NAME, HOLD_REASON, HOLD_DESCRIPTION);        
+        NodeRef newHold = holdService.createHold(filePlan, HOLD_NAME, HOLD_REASON, HOLD_DESCRIPTION);
         assertNotNull(newHold);
         assertEquals(TYPE_HOLD, mockedNodeService.getType(newHold));
         assertEquals(hold, newHold);
-        
+
         // check the node service interactions
         ArgumentCaptor<Map> propertyMapCaptor = ArgumentCaptor.forClass(Map.class);
         ArgumentCaptor<QName> assocNameCaptor = ArgumentCaptor.forClass(QName.class);
         verify(mockedNodeService).createNode(eq(holdContainer), eq(ContentModel.ASSOC_CONTAINS), assocNameCaptor.capture() , eq(TYPE_HOLD), propertyMapCaptor.capture());
-        
+
         // check property map
         Map<QName, Serializable> propertyMap = (Map<QName, Serializable>)propertyMapCaptor.getValue();
         assertNotNull(propertyMap);
@@ -263,13 +262,13 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         assertEquals(HOLD_DESCRIPTION, propertyMap.get(ContentModel.PROP_DESCRIPTION));
         assertTrue(propertyMap.containsKey(PROP_HOLD_REASON));
         assertEquals(HOLD_REASON, propertyMap.get(PROP_HOLD_REASON));
-        
+
         // check assoc name
         assertNotNull(assocNameCaptor.getValue());
         assertEquals(NamespaceService.CONTENT_MODEL_1_0_URI, assocNameCaptor.getValue().getNamespaceURI());
-        assertEquals(HOLD_NAME, assocNameCaptor.getValue().getLocalName());        
+        assertEquals(HOLD_NAME, assocNameCaptor.getValue().getLocalName());
     }
-    
+
     @Test
     public void getHoldReason()
     {
@@ -282,20 +281,20 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         when(mockedNodeService.getProperty(eq(hold), eq(PROP_HOLD_REASON)))
             .thenReturn(null)
             .thenReturn(HOLD_REASON);
-        
+
         // node does not exist
         assertNull(holdService.getHoldReason(hold));
-        
+
         // node isn't a hold
         assertNull(holdService.getHoldReason(recordFolder));
-        
+
         // hold reason isn't set
         assertNull(holdService.getHoldReason(hold));
-        
+
         // hold reason set
         assertEquals(HOLD_REASON, holdService.getHoldReason(hold));
     }
-    
+
     @Test
     public void setHoldReason()
     {
@@ -304,93 +303,93 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
             .thenReturn(false)
             .thenReturn(true)
             .thenReturn(true);
-        
+
         // node does not exist
         holdService.setHoldReason(hold, HOLD_REASON);
-        verify(mockedNodeService, never()).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);     
+        verify(mockedNodeService, never()).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);
-        
+
         // node isn't a hold
         holdService.setHoldReason(recordFolder, HOLD_REASON);
-        verify(mockedNodeService, never()).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);  
+        verify(mockedNodeService, never()).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);
-        
+
         // set hold reason
         holdService.setHoldReason(hold, HOLD_REASON);
-        verify(mockedNodeService).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);        
+        verify(mockedNodeService).setProperty(hold, PROP_HOLD_REASON, HOLD_REASON);
     }
-    
+
     @Test (expected=AlfrescoRuntimeException.class)
     public void deleteHoldNotAHold()
     {
         holdService.deleteHold(recordFolder);
-        verify(mockedNodeService, never()).deleteNode(hold);        
+        verify(mockedNodeService, never()).deleteNode(hold);
     }
-    
+
     @Test
     public void deleteHold()
     {
         // delete hold
         holdService.deleteHold(hold);
-        verify(mockedNodeService).deleteNode(hold);   
+        verify(mockedNodeService).deleteNode(hold);
-        
+
         // TODO check interactions with policy component!!!
     }
-    
+
     @Test (expected=AlfrescoRuntimeException.class)
     public void addToHoldNotAHold()
     {
         holdService.addToHold(recordFolder, recordFolder);
     }
-    
+
     @Test (expected=AlfrescoRuntimeException.class)
     public void addToHoldNotARecordFolderOrRecord()
     {
         holdService.addToHold(hold, filePlanComponent);
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void addToHoldNotInHold()
     {
         holdService.addToHold(hold, recordFolder);
-        
+
         verify(mockedNodeService).addChild(hold, recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService).addAspect(eq(recordFolder), eq(ASPECT_FROZEN), any(Map.class));
         verify(mockedNodeService).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));
-        
+
         holdService.addToHold(hold, record);
         verify(mockedNodeService).addChild(hold, record, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService).addAspect(eq(recordFolder), eq(ASPECT_FROZEN), any(Map.class));
         verify(mockedNodeService, times(2)).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void addToHoldAlreadyInHold()
     {
         doReturn(Collections.singletonList(recordFolder)).when(holdService).getHeld(hold);
-        
+
         holdService.addToHold(hold, recordFolder);
-        
+
         verify(mockedNodeService, never()).addChild(hold, recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService, never()).addAspect(eq(recordFolder), eq(ASPECT_FROZEN), any(Map.class));
         verify(mockedNodeService, never()).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));
-        
+
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void addToHoldAldeadyFrozen()
     {
         doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
         doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
-        
+
         holdService.addToHold(hold, recordFolder);
-        
+
         verify(mockedNodeService, times(1)).addChild(hold, recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService, never()).addAspect(eq(recordFolder), eq(ASPECT_FROZEN), any(Map.class));
         verify(mockedNodeService, never()).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void addToHolds()
@@ -404,54 +403,54 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
                 doReturn(true).when(mockedNodeService).hasAspect(nodeRef, ASPECT_FROZEN);
                 return null;
             }
-            
+
         }).when(mockedNodeService).addAspect(any(NodeRef.class), eq(ASPECT_FROZEN), any(Map.class));
-        
+
         // build a list of holds
         List<NodeRef> holds = new ArrayList<NodeRef>(2);
         holds.add(hold);
         holds.add(hold2);
-        
+
         // add the record folder to both holds
         holdService.addToHolds(holds, recordFolder);
-        
+
         // verify the interactions
         verify(mockedNodeService, times(1)).addChild(hold, recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService, times(1)).addChild(hold2, recordFolder, ASSOC_FROZEN_RECORDS, ASSOC_FROZEN_RECORDS);
         verify(mockedNodeService, times(1)).addAspect(eq(recordFolder), eq(ASPECT_FROZEN), any(Map.class));
-        verify(mockedNodeService, times(1)).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));                
+        verify(mockedNodeService, times(1)).addAspect(eq(record), eq(ASPECT_FROZEN), any(Map.class));
     }
-    
+
     @Test (expected=AlfrescoRuntimeException.class)
     public void removeFromHoldNotAHold()
     {
         holdService.removeFromHold(recordFolder, recordFolder);
     }
-    
+
     @Test
     public void removeFromHoldNotInHold()
     {
         holdService.removeFromHold(hold, recordFolder);
-        
+
         verify(mockedNodeService, never()).removeChild(hold, recordFolder);
         verify(mockedNodeService, never()).removeAspect(recordFolder, ASPECT_FROZEN);
         verify(mockedNodeService, never()).removeAspect(record, ASPECT_FROZEN);
     }
-    
+
     @Test
     public void removeFromHold()
     {
         doReturn(Collections.singletonList(recordFolder)).when(holdService).getHeld(hold);
         doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
         doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
-        
+
         holdService.removeFromHold(hold, recordFolder);
-        
+
         verify(mockedNodeService, times(1)).removeChild(hold, recordFolder);
         verify(mockedNodeService, times(1)).removeAspect(recordFolder, ASPECT_FROZEN);
         verify(mockedNodeService, times(1)).removeAspect(record, ASPECT_FROZEN);
     }
-    
+
     @Test
     public void removeFromHolds()
     {
@@ -459,20 +458,20 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         doReturn(Collections.singletonList(recordFolder)).when(holdService).getHeld(hold2);
         doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
         doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
-        
+
         // build a list of holds
         List<NodeRef> holds = new ArrayList<NodeRef>(2);
         holds.add(hold);
         holds.add(hold2);
-        
+
         holdService.removeFromHolds(holds, recordFolder);
-        
+
         verify(mockedNodeService, times(1)).removeChild(hold, recordFolder);
         verify(mockedNodeService, times(1)).removeChild(hold2, recordFolder);
         verify(mockedNodeService, times(1)).removeAspect(recordFolder, ASPECT_FROZEN);
         verify(mockedNodeService, times(1)).removeAspect(record, ASPECT_FROZEN);
     }
-    
+
     @Test
     public void removeFromAllHolds()
     {
@@ -480,7 +479,7 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
         List<NodeRef> holds = new ArrayList<NodeRef>(2);
         holds.add(hold);
         holds.add(hold2);
-        
+
         doAnswer(new Answer<Void>()
         {
             public Void answer(InvocationOnMock invocation)
@@ -488,9 +487,9 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
                 doReturn(Collections.singletonList(hold2)).when(holdService).heldBy(recordFolder, true);
                 return null;
             }
-            
+
         }).when(mockedNodeService).removeChild(hold, recordFolder);
-        
+
         doAnswer(new Answer<Void>()
         {
             public Void answer(InvocationOnMock invocation)
@@ -498,23 +497,23 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
                 doReturn(new ArrayList<NodeRef>()).when(holdService).heldBy(recordFolder, true);
                 return null;
             }
-            
+
         }).when(mockedNodeService).removeChild(hold2, recordFolder);
-        
+
         // define interactions
         doReturn(holds).when(holdService).heldBy(recordFolder, true);
         doReturn(Collections.singletonList(recordFolder)).when(holdService).getHeld(hold);
         doReturn(Collections.singletonList(recordFolder)).when(holdService).getHeld(hold2);
         doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
         doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
-        
+
         // remove record folder from all holds
         holdService.removeFromAllHolds(recordFolder);
-        
+
         // verify interactions
         verify(mockedNodeService, times(1)).removeChild(hold, recordFolder);
         verify(mockedNodeService, times(1)).removeChild(hold2, recordFolder);
         verify(mockedNodeService, times(1)).removeAspect(recordFolder, ASPECT_FROZEN);
-        verify(mockedNodeService, times(1)).removeAspect(record, ASPECT_FROZEN);        
+        verify(mockedNodeService, times(1)).removeAspect(record, ASPECT_FROZEN);
     }
 }