From bcee7331fdef74ea12483586bfb60d9ed5548457 Mon Sep 17 00:00:00 2001 From: Silviu Dinuta Date: Mon, 31 Oct 2016 13:43:52 +0200 Subject: [PATCH 1/4] RM-4012: added unit test classes and implemented parts of the unit tests --- .../rm/rest/api/impl/RMNodesImplUnitTest.java | 41 +++++ ...planComponentChildrenRelationUnitTest.java | 154 ++++++++++++++++++ ...eplanComponentsEntityResourceUnitTest.java | 76 +++++++++ 3 files changed, 271 insertions(+) create mode 100644 rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java create mode 100644 rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentChildrenRelationUnitTest.java create mode 100644 rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java new file mode 100644 index 0000000000..468f06837b --- /dev/null +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java @@ -0,0 +1,41 @@ +/* + * #%L + * Alfresco Records Management Module + * %% + * Copyright (C) 2005 - 2016 Alfresco Software Limited + * %% + * This file is part of the Alfresco software. + * - + * If the software was purchased under a paid Alfresco license, the terms of + * the paid license agreement will prevail. Otherwise, the software is + * provided under the following open source license terms: + * - + * 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 . + * #L% + */ + +package org.alfresco.rm.rest.api.impl; + +import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; + +/** + * Unit Test class for RMNodesImpl. + * + * @author Silviu Dinuta + * @since 2.6 + */ +public class RMNodesImplUnitTest extends BaseUnitTest +{ + +} diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentChildrenRelationUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentChildrenRelationUnitTest.java new file mode 100644 index 0000000000..9d05314ff7 --- /dev/null +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentChildrenRelationUnitTest.java @@ -0,0 +1,154 @@ +/* + * #%L + * Alfresco Records Management Module + * %% + * Copyright (C) 2005 - 2016 Alfresco Software Limited + * %% + * This file is part of the Alfresco software. + * - + * If the software was purchased under a paid Alfresco license, the terms of + * the paid license agreement will prevail. Otherwise, the software is + * provided under the following open source license terms: + * - + * 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 . + * #L% + */ + +package org.alfresco.rm.rest.api.nodes; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +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.when; + +import java.util.ArrayList; +import java.util.List; + +import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock; +import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; +import org.alfresco.rest.api.model.Node; +import org.alfresco.rest.framework.core.exceptions.PermissionDeniedException; +import org.alfresco.rest.framework.resource.parameters.Parameters; +import org.alfresco.rest.framework.webscripts.WithResponse; +import org.alfresco.rm.rest.api.impl.RMNodesImpl; +import org.alfresco.service.cmr.repository.NodeRef; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.extensions.webscripts.servlet.FormData; + +/** + * Unit Test class for FileplanComponentChildrenRelation. + * + * @author Silviu Dinuta + * @since 2.6 + * + */ +public class FileplanComponentChildrenRelationUnitTest extends BaseUnitTest +{ + + @Mock + private RMNodesImpl mockedRMNodes; + + @InjectMocks + private FileplanComponentChildrenRelation filePlanComponentChildrenRelation; + + @Before + public void before() + { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testReadAll() throws Exception + { + Parameters mockedParameters = mock(Parameters.class); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + filePlanComponentChildrenRelation.readAll(parentNodeRef.getId(), mockedParameters); + verify(mockedRMNodes, times(1)).listChildren(parentNodeRef.getId(), mockedParameters); + } + + @Test + public void testCreate() throws Exception + { + Parameters mockedParameters = mock(Parameters.class); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + + List nodeInfos = new ArrayList(); + Node mokedNodeInfo = mock(Node.class); + nodeInfos.add(mokedNodeInfo); + + filePlanComponentChildrenRelation.create(parentNodeRef.getId(), nodeInfos, mockedParameters); + verify(mockedRMNodes, times(1)).createNode(parentNodeRef.getId(), nodeInfos.get(0), mockedParameters); + } + + @Test + public void testCreateOnRMSite() throws Exception + { + Parameters mockedParameters = mock(Parameters.class); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + + List nodeInfos = new ArrayList(); + Node mokedNodeInfo = mock(Node.class); + nodeInfos.add(mokedNodeInfo); + + when(mockedRMNodes.isRMSite(parentNodeRef.getId())).thenReturn(true); + try + { + filePlanComponentChildrenRelation.create(parentNodeRef.getId(), nodeInfos, mockedParameters); + fail("Expected ecxeption as POST request is not allowed in RM site."); + } + catch(PermissionDeniedException ex) + { + assertEquals("POST request not allowed in RM site.", ex.getMsgId()); + } + verify(mockedRMNodes, never()).createNode(parentNodeRef.getId(), nodeInfos.get(0), mockedParameters); + } + + public void testUpload() throws Exception + { + Parameters mockedParameters = mock(Parameters.class); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + FormData mockedFormData = mock(FormData.class); + WithResponse mockedWithResponse = mock(WithResponse.class); + filePlanComponentChildrenRelation.create(parentNodeRef.getId(), mockedFormData, mockedParameters, mockedWithResponse); + verify(mockedRMNodes, times(1)).upload(parentNodeRef.getId(), mockedFormData, mockedParameters); + } + + public void testUploadOnRMSite() throws Exception + { + Parameters mockedParameters = mock(Parameters.class); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + FormData mockedFormData = mock(FormData.class); + WithResponse mockedWithResponse = mock(WithResponse.class); + + when(mockedRMNodes.isRMSite(parentNodeRef.getId())).thenReturn(true); + try + { + filePlanComponentChildrenRelation.create(parentNodeRef.getId(), mockedFormData, mockedParameters, mockedWithResponse); + fail("Expected ecxeption as POST request is not allowed in RM site."); + } + catch(PermissionDeniedException ex) + { + assertEquals("POST request not allowed in RM site.", ex.getMsgId()); + } + verify(mockedRMNodes, never()).upload(parentNodeRef.getId(), mockedFormData, mockedParameters); + } +} diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java new file mode 100644 index 0000000000..f17e88eda8 --- /dev/null +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java @@ -0,0 +1,76 @@ +/* + * #%L + * Alfresco Records Management Module + * %% + * Copyright (C) 2005 - 2016 Alfresco Software Limited + * %% + * This file is part of the Alfresco software. + * - + * If the software was purchased under a paid Alfresco license, the terms of + * the paid license agreement will prevail. Otherwise, the software is + * provided under the following open source license terms: + * - + * 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 . + * #L% + */ + +package org.alfresco.rm.rest.api.nodes; + +import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; +import org.alfresco.rm.rest.api.impl.RMNodesImpl; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** + * Unit Test class for FileplanComponentsEntityResource. + * + * @author Silviu Dinuta + * @since 2.6 + * + */ +public class FileplanComponentsEntityResourceUnitTest extends BaseUnitTest +{ + @Mock + private RMNodesImpl mockedRMNodes; + + @InjectMocks + private FileplanComponentsEntityResource filePlanComponentsEntityResource; + + @Before + public void before() + { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testReadById() throws Exception + { + + } + + @Test + public void testUpdate() throws Exception + { + + } + + @Test + public void testDelete() throws Exception + { + + } +} From 01aaf952ea3bd9737fa5fa943bec54cda4ce12c5 Mon Sep 17 00:00:00 2001 From: Silviu Dinuta Date: Mon, 31 Oct 2016 14:41:05 +0200 Subject: [PATCH 2/4] RM-4012: finalised FileplanComponentsEntityResource unit tests --- ...eplanComponentsEntityResourceUnitTest.java | 48 ++++++++++++++++++- 1 file changed, 46 insertions(+), 2 deletions(-) diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java index f17e88eda8..ee88ff470e 100644 --- a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java @@ -27,8 +27,21 @@ package org.alfresco.rm.rest.api.nodes; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +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.when; + +import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock; import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; +import org.alfresco.rest.api.model.Node; +import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException; +import org.alfresco.rest.framework.resource.parameters.Parameters; import org.alfresco.rm.rest.api.impl.RMNodesImpl; +import org.alfresco.service.cmr.repository.NodeRef; import org.junit.Before; import org.junit.Test; import org.mockito.InjectMocks; @@ -44,6 +57,8 @@ import org.mockito.MockitoAnnotations; */ public class FileplanComponentsEntityResourceUnitTest extends BaseUnitTest { + private static final String PERMANENT_PARAMETER = "permanent"; + @Mock private RMNodesImpl mockedRMNodes; @@ -59,18 +74,47 @@ public class FileplanComponentsEntityResourceUnitTest extends BaseUnitTest @Test public void testReadById() throws Exception { - + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + filePlanComponentsEntityResource.readById(parentNodeRef.getId(), mockedParameters); + verify(mockedRMNodes, times(1)).getFolderOrDocument(parentNodeRef.getId(), mockedParameters); } @Test public void testUpdate() throws Exception { - + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + Node mockedNodeInfo = mock(Node.class); + filePlanComponentsEntityResource.update(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); + verify(mockedRMNodes, times(1)).updateNode(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); } @Test public void testDelete() throws Exception { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(null); + filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); + verify(mockedRMNodes, times(1)).deleteNode(parentNodeRef.getId(), mockedParameters); + } + @Test + public void testDeleteWithPermanentParameter() throws Exception + { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(Boolean.toString(true)); + try + { + filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); + fail("Expected ecxeption as DELETE does not support parameter: permanent."); + } + catch(InvalidArgumentException ex) + { + assertEquals("DELETE does not support parameter: permanent", ex.getMsgId()); + } + verify(mockedRMNodes, never()).deleteNode(parentNodeRef.getId(), mockedParameters); } } From e139ef6b7d988f0ce6e58c457f12b52be510103a Mon Sep 17 00:00:00 2001 From: Silviu Dinuta Date: Tue, 1 Nov 2016 02:40:10 +0200 Subject: [PATCH 3/4] RM-4012: finalised unit tests --- .../rm/rest/api/impl/RMNodesImplUnitTest.java | 926 +++++++++++++++++- ...eplanComponentsEntityResourceUnitTest.java | 241 ++--- 2 files changed, 1006 insertions(+), 161 deletions(-) diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java index 468f06837b..4bc0248350 100644 --- a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java @@ -1,41 +1,885 @@ -/* - * #%L - * Alfresco Records Management Module - * %% - * Copyright (C) 2005 - 2016 Alfresco Software Limited - * %% - * This file is part of the Alfresco software. - * - - * If the software was purchased under a paid Alfresco license, the terms of - * the paid license agreement will prevail. Otherwise, the software is - * provided under the following open source license terms: - * - - * 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 . - * #L% - */ - -package org.alfresco.rm.rest.api.impl; - -import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; - -/** - * Unit Test class for RMNodesImpl. - * - * @author Silviu Dinuta - * @since 2.6 - */ -public class RMNodesImplUnitTest extends BaseUnitTest -{ - -} +/* + * #%L + * Alfresco Records Management Module + * %% + * Copyright (C) 2005 - 2016 Alfresco Software Limited + * %% + * This file is part of the Alfresco software. + * - + * If the software was purchased under a paid Alfresco license, the terms of + * the paid license agreement will prevail. Otherwise, the software is + * provided under the following open source license terms: + * - + * 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 . + * #L% + */ + +package org.alfresco.rm.rest.api.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +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.when; + +import java.io.Serializable; +import java.security.InvalidParameterException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.alfresco.model.ContentModel; +import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionSchedule; +import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel; +import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock; +import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; +import org.alfresco.repo.model.Repository; +import org.alfresco.rest.api.model.Node; +import org.alfresco.rest.framework.core.exceptions.EntityNotFoundException; +import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException; +import org.alfresco.rest.framework.core.exceptions.PermissionDeniedException; +import org.alfresco.rest.framework.resource.parameters.Parameters; +import org.alfresco.rm.rest.api.RMNodes; +import org.alfresco.rm.rest.api.model.FileplanComponentNode; +import org.alfresco.rm.rest.api.model.RecordCategoryNode; +import org.alfresco.rm.rest.api.model.RecordFolderNode; +import org.alfresco.rm.rest.api.model.RecordNode; +import org.alfresco.service.ServiceRegistry; +import org.alfresco.service.cmr.dictionary.DataTypeDefinition; +import org.alfresco.service.cmr.dictionary.PropertyDefinition; +import org.alfresco.service.cmr.repository.ChildAssociationRef; +import org.alfresco.service.cmr.repository.NodeRef; +import org.alfresco.service.cmr.security.AccessStatus; +import org.alfresco.service.cmr.security.PermissionService; +import org.alfresco.service.cmr.security.PersonService; +import org.alfresco.service.cmr.site.SiteInfo; +import org.alfresco.service.cmr.site.SiteService; +import org.alfresco.service.namespace.NamespaceService; +import org.alfresco.service.namespace.QName; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** + * Unit Test class for RMNodesImpl. + * + * @author Silviu Dinuta + * @since 2.6 + */ +public class RMNodesImplUnitTest extends BaseUnitTest +{ + private static final String UNFILED_ALIAS = "-unfiled-"; + + private static final String HOLDS_ALIAS = "-holds-"; + + private static final String TRANSFERS_ALIAS = "-transfers-"; + + private static final String FILE_PLAN_ALIAS = "-filePlan-"; + + private static final String RM_SITE_ID = "rm"; + + @Mock + private SiteService mockedSiteService; + + @Mock + private Repository mockedRepositoryHelper; + + @Mock + private PersonService mockedPersonService; + + @Mock + private ServiceRegistry mockedServiceRegistry; + + @InjectMocks + private RMNodesImpl rmNodesImpl; + + @Before + public void before() + { + MockitoAnnotations.initMocks(this); + + List prefixes = new ArrayList(); + prefixes.add(NamespaceService.DEFAULT_PREFIX); + when(mockedNamespaceService.getPrefixes(any(String.class))).thenReturn(prefixes); + when(mockedNamespaceService.getNamespaceURI(any(String.class))).thenReturn(RM_URI); + + } + + @Test + public void testGetFileplanComponent() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_CMOBJECT)).thenReturn(true); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_SYSTEM_FOLDER)).thenReturn(false); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true); + List includeParamList = new ArrayList(); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(FileplanComponentNode.class.isInstance(folderOrDocument)); + + FileplanComponentNode resultNode = (FileplanComponentNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + } + + @Test + public void testGetFilePlanAllowableOperations() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_CMOBJECT)).thenReturn(true); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_SYSTEM_FOLDER)).thenReturn(false); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_FOLDER)).thenReturn(true); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true); + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS); + + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.WRITE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.DELETE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.ADD_CHILDREN)).thenReturn(AccessStatus.ALLOWED); + + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(nodeRef); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(FileplanComponentNode.class.isInstance(folderOrDocument)); + + FileplanComponentNode resultNode = (FileplanComponentNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + List allowableOperations = resultNode.getAllowableOperations(); + assertTrue("Create operation should be available for FilePlan.", allowableOperations.contains(RMNodes.OP_CREATE)); + assertTrue("Update operation should be available for FilePlan.", allowableOperations.contains(RMNodes.OP_UPDATE)); + assertFalse("Delete operation should note be available for FilePlan.", allowableOperations.contains(RMNodes.OP_DELETE)); + } + + @Test + public void testGetTransferContainerAllowableOperations() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_CATEGORY); + when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_RECORD_CATEGORY, ContentModel.TYPE_FOLDER)).thenReturn(true); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS); + + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.WRITE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.DELETE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.ADD_CHILDREN)).thenReturn(AccessStatus.ALLOWED); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(nodeRef); + + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + RecordCategoryNode resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + List allowableOperations = resultNode.getAllowableOperations(); + assertTrue("Create operation should be available for Transfers container.", allowableOperations.contains(RMNodes.OP_CREATE)); + assertTrue("Update operation should be available for Transfers container.", allowableOperations.contains(RMNodes.OP_UPDATE)); + assertFalse("Delete operation should note be available for Transfers container.", allowableOperations.contains(RMNodes.OP_DELETE)); + } + + @Test + public void testGetHoldContainerAllowableOperations() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_CATEGORY); + when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_RECORD_CATEGORY, ContentModel.TYPE_FOLDER)).thenReturn(true); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS); + + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.WRITE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.DELETE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.ADD_CHILDREN)).thenReturn(AccessStatus.ALLOWED); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); + + when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(nodeRef); + + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + RecordCategoryNode resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + List allowableOperations = resultNode.getAllowableOperations(); + assertTrue("Create operation should be available for Holds container.", allowableOperations.contains(RMNodes.OP_CREATE)); + assertTrue("Update operation should be available for Holds container.", allowableOperations.contains(RMNodes.OP_UPDATE)); + assertFalse("Delete operation should note be available for Holds container.", allowableOperations.contains(RMNodes.OP_DELETE)); + } + + @Test + public void testGetUnfiledContainerAllowableOperations() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_CATEGORY); + when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_RECORD_CATEGORY, ContentModel.TYPE_FOLDER)).thenReturn(true); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS); + + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.WRITE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.DELETE)).thenReturn(AccessStatus.ALLOWED); + when(mockedPermissionService.hasPermission(nodeRef, PermissionService.ADD_CHILDREN)).thenReturn(AccessStatus.ALLOWED); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); + + NodeRef holdContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(holdContainerNodeRef); + + when(mockedFilePlanService.getUnfiledContainer(filePlanNodeRef)).thenReturn(nodeRef); + + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + RecordCategoryNode resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + List allowableOperations = resultNode.getAllowableOperations(); + assertTrue("Create operation should be available for Unfiled Records container.", allowableOperations.contains(RMNodes.OP_CREATE)); + assertTrue("Update operation should be available for Unfiled Records container.", allowableOperations.contains(RMNodes.OP_UPDATE)); + assertFalse("Delete operation should note be available for Unfiled Records container.", allowableOperations.contains(RMNodes.OP_DELETE)); + } + + @Test + public void testGetNonFileplanComponent() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_CMOBJECT)).thenReturn(true); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_SYSTEM_FOLDER)).thenReturn(false); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(false); + List includeParamList = new ArrayList(); + try + { + rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + fail("Expected exception since the requested node is not a fileplan component."); + } + catch(InvalidParameterException ex) + { + assertEquals("The provided node is not a fileplan component", ex.getMessage()); + } + + } + + @Test + public void testGetRecordCategory() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_CATEGORY); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + RecordCategoryNode resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + } + + @Test + public void testGetRecordCategoryWithHasRetentionScheduleParam() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_CATEGORY); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_HAS_RETENTION_SCHEDULE); + + //test has retention schedule true + DispositionSchedule mockedDispositionSchedule = mock(DispositionSchedule.class); + when(mockedDispositionService.getDispositionSchedule(nodeRef)).thenReturn(mockedDispositionSchedule); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + RecordCategoryNode resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + assertEquals(true, resultNode.getHasRetentionSchedule()); + + //test has retention schedule false + when(mockedDispositionService.getDispositionSchedule(nodeRef)).thenReturn(null); + folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordCategoryNode.class.isInstance(folderOrDocument)); + + resultNode = (RecordCategoryNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(true, resultNode.getIsCategory()); + assertEquals(false, resultNode.getHasRetentionSchedule()); + } + + @Test + public void testGetRecordFolder() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_FOLDER); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordFolderNode.class.isInstance(folderOrDocument)); + + RecordFolderNode resultNode = (RecordFolderNode) folderOrDocument; + assertEquals(true, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + } + + @Test + public void testGetRecordFolderWithIsClosedParam() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_RECORD_FOLDER); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + includeParamList.add(RMNodes.PARAM_INCLUDE_IS_CLOSED); + + //check closed record folder + when(mockedNodeService.getProperty(nodeRef, RecordsManagementModel.PROP_IS_CLOSED)).thenReturn(true); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordFolderNode.class.isInstance(folderOrDocument)); + + RecordFolderNode resultNode = (RecordFolderNode) folderOrDocument; + assertEquals(true, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + assertEquals(true, resultNode.getIsClosed()); + + //check opened record folder + when(mockedNodeService.getProperty(nodeRef, RecordsManagementModel.PROP_IS_CLOSED)).thenReturn(false); + folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordFolderNode.class.isInstance(folderOrDocument)); + + resultNode = (RecordFolderNode) folderOrDocument; + assertEquals(true, resultNode.getIsRecordFolder()); + assertEquals(false, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + assertEquals(false, resultNode.getIsClosed()); + } + + @Test + public void testGetRecord() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(ContentModel.TYPE_CONTENT); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordNode.class.isInstance(folderOrDocument)); + + RecordNode resultNode = (RecordNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(true, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + } + + @Test + public void testGetRecordWithIsCompletedParam() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedNodeService.getType(nodeRef)).thenReturn(ContentModel.TYPE_CONTENT); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + List includeParamList = new ArrayList(); + + includeParamList.add(RMNodes.PARAM_INCLUDE_IS_COMPLETED); + + //test completed record + when(mockedNodeService.hasAspect(nodeRef, RecordsManagementModel.ASPECT_DECLARED_RECORD)).thenReturn(true); + Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordNode.class.isInstance(folderOrDocument)); + + RecordNode resultNode = (RecordNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(true, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + assertEquals(true, resultNode.getIsCompleted()); + + //test incomplete record + when(mockedNodeService.hasAspect(nodeRef, RecordsManagementModel.ASPECT_DECLARED_RECORD)).thenReturn(false); + folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null); + assertNotNull(folderOrDocument); + assertTrue(RecordNode.class.isInstance(folderOrDocument)); + + resultNode = (RecordNode) folderOrDocument; + assertEquals(false, resultNode.getIsRecordFolder()); + assertEquals(true, resultNode.getIsFile()); + assertEquals(false, resultNode.getIsCategory()); + assertEquals(false, resultNode.getIsCompleted()); + } + + @Test + public void testValidateorLookupNodeWithFilePlanAlias() throws Exception + { + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(FILE_PLAN_ALIAS, null); + assertEquals(filePlanNodeRef, validateOrLookupNode); + } + + @Test + public void testValidateorLookupNodeWithTransfersAlias() throws Exception + { + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); + + NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(TRANSFERS_ALIAS, null); + assertEquals(transferContainerNodeRef, validateOrLookupNode); + } + + @Test + public void testValidateorLookupNodeWithHoldsAlias() throws Exception + { + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef holdsContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(holdsContainerNodeRef); + + NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(HOLDS_ALIAS, null); + assertEquals(holdsContainerNodeRef, validateOrLookupNode); + } + + @Test + public void testValidateorLookupNodeWithUnfiledAlias() throws Exception + { + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef unfiledContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getUnfiledContainer(filePlanNodeRef)).thenReturn(unfiledContainerNodeRef); + + NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(UNFILED_ALIAS, null); + assertEquals(unfiledContainerNodeRef, validateOrLookupNode); + } + + @Test + public void testValidateorLookupNodeWithFilePlanAliasRMSiteNotCreated() throws Exception + { + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); + + try + { + rmNodesImpl.validateOrLookupNode(FILE_PLAN_ALIAS, null); + fail("Expected exception as RM site is not created."); + } + catch(EntityNotFoundException ex) + { + //it is ok since exception is thrown + } + } + + @Test + public void testValidateorLookupNodeWithTransferAliasRMSiteNotCreated() throws Exception + { + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); + + try + { + rmNodesImpl.validateOrLookupNode(TRANSFERS_ALIAS, null); + fail("Expected exception as RM site is not created."); + } + catch(EntityNotFoundException ex) + { + //it is ok since exception is thrown + } + } + + @Test + public void testValidateorLookupNodeWithHoldsAliasRMSiteNotCreated() throws Exception + { + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); + + try + { + rmNodesImpl.validateOrLookupNode(HOLDS_ALIAS, null); + fail("Expected exception as RM site is not created."); + } + catch(EntityNotFoundException ex) + { + //it is ok since exception is thrown + } + } + + @Test + public void testValidateorLookupNodeWithUnfiledAliasRMSiteNotCreated() throws Exception + { + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); + + try + { + rmNodesImpl.validateOrLookupNode(UNFILED_ALIAS, null); + fail("Expected exception as RM site is not created."); + } + catch(EntityNotFoundException ex) + { + //it is ok since exception is thrown + } + } + + @Test + public void testValidateorLookupNodeNullNodeRef() throws Exception + { + try + { + rmNodesImpl.validateOrLookupNode(null, null); + fail("Expected exception as nodId should not be null or empty."); + } + catch(InvalidArgumentException ex) + { + assertEquals("Missing nodeId", ex.getMsgId()); + } + } + + @Test + public void testValidateorLookupNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(nodeRef.getId(), null); + assertEquals(nodeRef, validateOrLookupNode); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test + public void testUpdateNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_CMOBJECT)).thenReturn(true); + when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_SYSTEM_FOLDER)).thenReturn(false); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + Parameters mockedParameters = mock(Parameters.class); + Node mockedNodeInfo = mock(Node.class); + Map nodeProperties = new HashMap<>(); + nodeProperties.put("cm:title", "New Title"); + nodeProperties.put("cm:description", "New Description"); + when(mockedNodeInfo.getProperties()).thenReturn(nodeProperties); + + PropertyDefinition mockedPropertyDefinition = mock(PropertyDefinition.class); + when(mockedDictionaryService.getProperty(any(QName.class))).thenReturn(mockedPropertyDefinition); + + DataTypeDefinition mockedDataTypeDef = mock(DataTypeDefinition.class); + when(mockedPropertyDefinition.getDataType()).thenReturn(mockedDataTypeDef); + when(mockedDataTypeDef.getName()).thenReturn(AlfMock.generateQName()); + when(mockedNamespaceService.getNamespaceURI(any(String.class))).thenReturn(NamespaceService.CONTENT_MODEL_1_0_URI); + + when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true); + + Node updatedNode = rmNodesImpl.updateNode(nodeRef.getId(), mockedNodeInfo, mockedParameters); + assertNotNull(updatedNode); + + ArgumentCaptor propertiesMapCaptor = ArgumentCaptor.forClass(Map.class); + verify(mockedNodeService, times(1)).addProperties(eq(nodeRef), propertiesMapCaptor.capture()); + + // check property map + Map propertyMap = (Map)propertiesMapCaptor.getValue(); + assertNotNull(propertyMap); + assertEquals(2, propertyMap.size()); + assertTrue(propertyMap.containsKey(ContentModel.PROP_DESCRIPTION)); + assertTrue(propertyMap.containsKey(ContentModel.PROP_TITLE)); + + + //TODO have a look on this after RM-4295 is fixed +// assertEquals("New Description", updatedNode.getDescription()); +// assertEquals("New Title", updatedNode.getTitle()); + } + + @Test + public void testDeleteNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + + NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); + when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); + when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); + + rmNodesImpl.deleteNode(nodeRef.getId(), mockedParameters); + verify(mockedFileFolderService, times(1)).delete(nodeRef); + } + + @Test + public void testDeleteFileplanNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(nodeRef); + try + { + rmNodesImpl.deleteNode(nodeRef.getId(), mockedParameters); + fail("Expected ecxeption as filePlan can't be deleted."); + } + catch(PermissionDeniedException ex) + { + assertEquals("Cannot delete: " + nodeRef.getId(), ex.getMsgId()); + } + verify(mockedFileFolderService, never()).delete(nodeRef); + } + + @Test + public void testDeleteTransfersContainerNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(nodeRef); + try + { + rmNodesImpl.deleteNode(nodeRef.getId(), mockedParameters); + fail("Expected ecxeption as Trnsfers container can't be deleted."); + } + catch(PermissionDeniedException ex) + { + assertEquals("Cannot delete: " + nodeRef.getId(), ex.getMsgId()); + } + verify(mockedFileFolderService, never()).delete(nodeRef); + } + + @Test + public void testDeleteHoldsContainerNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); + + when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(nodeRef); + try + { + rmNodesImpl.deleteNode(nodeRef.getId(), mockedParameters); + fail("Expected ecxeption as Holds container can't be deleted."); + } + catch(PermissionDeniedException ex) + { + assertEquals("Cannot delete: " + nodeRef.getId(), ex.getMsgId()); + } + verify(mockedFileFolderService, never()).delete(nodeRef); + } + + @Test + public void testDeleteUnfiledRecordsContainerNode() throws Exception + { + NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + QName mockedType = AlfMock.generateQName(); + when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); + + NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); + + NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); + + NodeRef holdContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); + when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(holdContainerNodeRef); + + when(mockedFilePlanService.getUnfiledContainer(filePlanNodeRef)).thenReturn(nodeRef); + try + { + rmNodesImpl.deleteNode(nodeRef.getId(), mockedParameters); + fail("Expected ecxeption as Unfiled Records container can't be deleted."); + } + catch(PermissionDeniedException ex) + { + assertEquals("Cannot delete: " + nodeRef.getId(), ex.getMsgId()); + } + verify(mockedFileFolderService, never()).delete(nodeRef); + } + + @Test + public void testIsRMSite() throws Exception + { + //test when rm site exists and we do not check the rm site + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + + NodeRef rmSiteNodeRef = AlfMock.generateNodeRef(mockedNodeService); + SiteInfo mockedSiteInfo = mock(SiteInfo.class); + when(mockedSiteInfo.getNodeRef()).thenReturn(rmSiteNodeRef); + when(mockedSiteService.getSite(RM_SITE_ID)).thenReturn(mockedSiteInfo); + + boolean isRMSite = rmNodesImpl.isRMSite(parentNodeRef.getId()); + assertEquals("Should return false.", false, isRMSite); + + //check when rm site does not exist + when(mockedSiteService.getSite(RM_SITE_ID)).thenReturn(null); + isRMSite = rmNodesImpl.isRMSite(parentNodeRef.getId()); + assertEquals("Should return false.", false, isRMSite); + + //check when rm site exists and we check with rm site node ref id + when(mockedSiteInfo.getNodeRef()).thenReturn(parentNodeRef); + when(mockedSiteService.getSite(RM_SITE_ID)).thenReturn(mockedSiteInfo); + isRMSite = rmNodesImpl.isRMSite(parentNodeRef.getId()); + assertEquals("Should return true.", true, isRMSite); + } +} diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java index ee88ff470e..2a36bf6f1a 100644 --- a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/nodes/FileplanComponentsEntityResourceUnitTest.java @@ -1,120 +1,121 @@ -/* - * #%L - * Alfresco Records Management Module - * %% - * Copyright (C) 2005 - 2016 Alfresco Software Limited - * %% - * This file is part of the Alfresco software. - * - - * If the software was purchased under a paid Alfresco license, the terms of - * the paid license agreement will prevail. Otherwise, the software is - * provided under the following open source license terms: - * - - * 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 . - * #L% - */ - -package org.alfresco.rm.rest.api.nodes; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; -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.when; - -import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock; -import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; -import org.alfresco.rest.api.model.Node; -import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException; -import org.alfresco.rest.framework.resource.parameters.Parameters; -import org.alfresco.rm.rest.api.impl.RMNodesImpl; -import org.alfresco.service.cmr.repository.NodeRef; -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -/** - * Unit Test class for FileplanComponentsEntityResource. - * - * @author Silviu Dinuta - * @since 2.6 - * - */ -public class FileplanComponentsEntityResourceUnitTest extends BaseUnitTest -{ - private static final String PERMANENT_PARAMETER = "permanent"; - - @Mock - private RMNodesImpl mockedRMNodes; - - @InjectMocks - private FileplanComponentsEntityResource filePlanComponentsEntityResource; - - @Before - public void before() - { - MockitoAnnotations.initMocks(this); - } - - @Test - public void testReadById() throws Exception - { - NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); - Parameters mockedParameters = mock(Parameters.class); - filePlanComponentsEntityResource.readById(parentNodeRef.getId(), mockedParameters); - verify(mockedRMNodes, times(1)).getFolderOrDocument(parentNodeRef.getId(), mockedParameters); - } - - @Test - public void testUpdate() throws Exception - { - NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); - Parameters mockedParameters = mock(Parameters.class); - Node mockedNodeInfo = mock(Node.class); - filePlanComponentsEntityResource.update(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); - verify(mockedRMNodes, times(1)).updateNode(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); - } - - @Test - public void testDelete() throws Exception - { - NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); - Parameters mockedParameters = mock(Parameters.class); - when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(null); - filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); - verify(mockedRMNodes, times(1)).deleteNode(parentNodeRef.getId(), mockedParameters); - } - - @Test - public void testDeleteWithPermanentParameter() throws Exception - { - NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); - Parameters mockedParameters = mock(Parameters.class); - when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(Boolean.toString(true)); - try - { - filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); - fail("Expected ecxeption as DELETE does not support parameter: permanent."); - } - catch(InvalidArgumentException ex) - { - assertEquals("DELETE does not support parameter: permanent", ex.getMsgId()); - } - verify(mockedRMNodes, never()).deleteNode(parentNodeRef.getId(), mockedParameters); - } -} +/* + * #%L + * Alfresco Records Management Module + * %% + * Copyright (C) 2005 - 2016 Alfresco Software Limited + * %% + * This file is part of the Alfresco software. + * - + * If the software was purchased under a paid Alfresco license, the terms of + * the paid license agreement will prevail. Otherwise, the software is + * provided under the following open source license terms: + * - + * 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 . + * #L% + */ + +package org.alfresco.rm.rest.api.nodes; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +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.when; + +import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock; +import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; +import org.alfresco.rest.api.model.Node; +import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException; +import org.alfresco.rest.framework.resource.parameters.Parameters; +import org.alfresco.rm.rest.api.impl.RMNodesImpl; +import org.alfresco.service.cmr.repository.NodeRef; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** + * Unit Test class for FileplanComponentsEntityResource. + * + * @author Silviu Dinuta + * @since 2.6 + * + */ +public class FileplanComponentsEntityResourceUnitTest extends BaseUnitTest +{ + private static final String PERMANENT_PARAMETER = "permanent"; + + @Mock + private RMNodesImpl mockedRMNodes; + + @InjectMocks + private FileplanComponentsEntityResource filePlanComponentsEntityResource; + + @Before + public void before() + { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testReadById() throws Exception + { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + filePlanComponentsEntityResource.readById(parentNodeRef.getId(), mockedParameters); + verify(mockedRMNodes, times(1)).getFolderOrDocument(parentNodeRef.getId(), mockedParameters); + } + + @Test + public void testUpdate() throws Exception + { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + Node mockedNodeInfo = mock(Node.class); + filePlanComponentsEntityResource.update(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); + verify(mockedRMNodes, times(1)).updateNode(parentNodeRef.getId(), mockedNodeInfo, mockedParameters); + } + + @Test + public void testDelete() throws Exception + { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(null); + filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); + verify(mockedRMNodes, times(1)).deleteNode(parentNodeRef.getId(), mockedParameters); + } + + @Test + public void testDeleteWithPermanentParameter() throws Exception + { + NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); + Parameters mockedParameters = mock(Parameters.class); + when(mockedParameters.getParameter(PERMANENT_PARAMETER)).thenReturn(Boolean.toString(true)); + + try + { + filePlanComponentsEntityResource.delete(parentNodeRef.getId(), mockedParameters); + fail("Expected ecxeption as DELETE does not support parameter: permanent."); + } + catch(InvalidArgumentException ex) + { + assertEquals("DELETE does not support parameter: permanent", ex.getMsgId()); + } + verify(mockedRMNodes, never()).deleteNode(parentNodeRef.getId(), mockedParameters); + } +} From 44cea31282f32a056230f3f285d724dec60a2afd Mon Sep 17 00:00:00 2001 From: Silviu Dinuta Date: Tue, 1 Nov 2016 11:03:31 +0200 Subject: [PATCH 4/4] RM-4012: did some changes after update method was removed and used validateNode instead validateOrLookup method --- .../rm/rest/api/impl/RMNodesImplUnitTest.java | 105 ++++-------------- 1 file changed, 22 insertions(+), 83 deletions(-) diff --git a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java index 4bc0248350..4bfecd6161 100644 --- a/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java +++ b/rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java @@ -33,19 +33,15 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.Matchers.any; -import static org.mockito.Matchers.eq; 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.when; -import java.io.Serializable; import java.security.InvalidParameterException; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; import org.alfresco.model.ContentModel; import org.alfresco.module.org_alfresco_module_rm.disposition.DispositionSchedule; @@ -55,7 +51,6 @@ import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest; import org.alfresco.repo.model.Repository; import org.alfresco.rest.api.model.Node; import org.alfresco.rest.framework.core.exceptions.EntityNotFoundException; -import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException; import org.alfresco.rest.framework.core.exceptions.PermissionDeniedException; import org.alfresco.rest.framework.resource.parameters.Parameters; import org.alfresco.rm.rest.api.RMNodes; @@ -64,8 +59,6 @@ import org.alfresco.rm.rest.api.model.RecordCategoryNode; import org.alfresco.rm.rest.api.model.RecordFolderNode; import org.alfresco.rm.rest.api.model.RecordNode; import org.alfresco.service.ServiceRegistry; -import org.alfresco.service.cmr.dictionary.DataTypeDefinition; -import org.alfresco.service.cmr.dictionary.PropertyDefinition; import org.alfresco.service.cmr.repository.ChildAssociationRef; import org.alfresco.service.cmr.repository.NodeRef; import org.alfresco.service.cmr.security.AccessStatus; @@ -77,7 +70,6 @@ import org.alfresco.service.namespace.NamespaceService; import org.alfresco.service.namespace.QName; import org.junit.Before; import org.junit.Test; -import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; @@ -551,16 +543,16 @@ public class RMNodesImplUnitTest extends BaseUnitTest } @Test - public void testValidateorLookupNodeWithFilePlanAlias() throws Exception + public void testValidateNodeWithFilePlanAlias() throws Exception { NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); - NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(FILE_PLAN_ALIAS, null); + NodeRef validateOrLookupNode = rmNodesImpl.validateNode(FILE_PLAN_ALIAS); assertEquals(filePlanNodeRef, validateOrLookupNode); } @Test - public void testValidateorLookupNodeWithTransfersAlias() throws Exception + public void testValidateNodeWithTransfersAlias() throws Exception { NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); @@ -568,12 +560,12 @@ public class RMNodesImplUnitTest extends BaseUnitTest NodeRef transferContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(transferContainerNodeRef); - NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(TRANSFERS_ALIAS, null); + NodeRef validateOrLookupNode = rmNodesImpl.validateNode(TRANSFERS_ALIAS); assertEquals(transferContainerNodeRef, validateOrLookupNode); } @Test - public void testValidateorLookupNodeWithHoldsAlias() throws Exception + public void testValidateNodeWithHoldsAlias() throws Exception { NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); @@ -581,12 +573,12 @@ public class RMNodesImplUnitTest extends BaseUnitTest NodeRef holdsContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getHoldContainer(filePlanNodeRef)).thenReturn(holdsContainerNodeRef); - NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(HOLDS_ALIAS, null); + NodeRef validateOrLookupNode = rmNodesImpl.validateNode(HOLDS_ALIAS); assertEquals(holdsContainerNodeRef, validateOrLookupNode); } @Test - public void testValidateorLookupNodeWithUnfiledAlias() throws Exception + public void testValidateNodeWithUnfiledAlias() throws Exception { NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef); @@ -594,18 +586,18 @@ public class RMNodesImplUnitTest extends BaseUnitTest NodeRef unfiledContainerNodeRef = AlfMock.generateNodeRef(mockedNodeService); when(mockedFilePlanService.getUnfiledContainer(filePlanNodeRef)).thenReturn(unfiledContainerNodeRef); - NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(UNFILED_ALIAS, null); + NodeRef validateOrLookupNode = rmNodesImpl.validateNode(UNFILED_ALIAS); assertEquals(unfiledContainerNodeRef, validateOrLookupNode); } @Test - public void testValidateorLookupNodeWithFilePlanAliasRMSiteNotCreated() throws Exception + public void testValidateNodeWithFilePlanAliasRMSiteNotCreated() throws Exception { when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); try { - rmNodesImpl.validateOrLookupNode(FILE_PLAN_ALIAS, null); + rmNodesImpl.validateNode(FILE_PLAN_ALIAS); fail("Expected exception as RM site is not created."); } catch(EntityNotFoundException ex) @@ -615,13 +607,13 @@ public class RMNodesImplUnitTest extends BaseUnitTest } @Test - public void testValidateorLookupNodeWithTransferAliasRMSiteNotCreated() throws Exception + public void testValidateNodeWithTransferAliasRMSiteNotCreated() throws Exception { when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); try { - rmNodesImpl.validateOrLookupNode(TRANSFERS_ALIAS, null); + rmNodesImpl.validateNode(TRANSFERS_ALIAS); fail("Expected exception as RM site is not created."); } catch(EntityNotFoundException ex) @@ -631,13 +623,13 @@ public class RMNodesImplUnitTest extends BaseUnitTest } @Test - public void testValidateorLookupNodeWithHoldsAliasRMSiteNotCreated() throws Exception + public void testValidateNodeWithHoldsAliasRMSiteNotCreated() throws Exception { when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); try { - rmNodesImpl.validateOrLookupNode(HOLDS_ALIAS, null); + rmNodesImpl.validateNode(HOLDS_ALIAS); fail("Expected exception as RM site is not created."); } catch(EntityNotFoundException ex) @@ -647,13 +639,13 @@ public class RMNodesImplUnitTest extends BaseUnitTest } @Test - public void testValidateorLookupNodeWithUnfiledAliasRMSiteNotCreated() throws Exception + public void testValidateNodeWithUnfiledAliasRMSiteNotCreated() throws Exception { when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null); try { - rmNodesImpl.validateOrLookupNode(UNFILED_ALIAS, null); + rmNodesImpl.validateNode(UNFILED_ALIAS); fail("Expected exception as RM site is not created."); } catch(EntityNotFoundException ex) @@ -663,80 +655,27 @@ public class RMNodesImplUnitTest extends BaseUnitTest } @Test - public void testValidateorLookupNodeNullNodeRef() throws Exception + public void testValidateNodeNullNodeRef() throws Exception { try { - rmNodesImpl.validateOrLookupNode(null, null); + rmNodesImpl.validateNode((String)null); fail("Expected exception as nodId should not be null or empty."); } - catch(InvalidArgumentException ex) + catch(IllegalArgumentException ex) { - assertEquals("Missing nodeId", ex.getMsgId()); + assertEquals("nodeId is a mandatory parameter", ex.getMessage()); } } @Test - public void testValidateorLookupNode() throws Exception + public void testValidateNode() throws Exception { NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); - NodeRef validateOrLookupNode = rmNodesImpl.validateOrLookupNode(nodeRef.getId(), null); + NodeRef validateOrLookupNode = rmNodesImpl.validateNode(nodeRef.getId()); assertEquals(nodeRef, validateOrLookupNode); } - @SuppressWarnings({ "unchecked", "rawtypes" }) - @Test - public void testUpdateNode() throws Exception - { - NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService); - QName mockedType = AlfMock.generateQName(); - when(mockedNodeService.getType(nodeRef)).thenReturn(mockedType); - when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_CMOBJECT)).thenReturn(true); - when(mockedDictionaryService.isSubClass(mockedType, ContentModel.TYPE_SYSTEM_FOLDER)).thenReturn(false); - - NodeRef companyHomeNodeRef = AlfMock.generateNodeRef(mockedNodeService); - when(mockedRepositoryHelper.getCompanyHome()).thenReturn(companyHomeNodeRef); - NodeRef parentNodeRef = AlfMock.generateNodeRef(mockedNodeService); - ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class); - when(mockedChildAssoc.getParentRef()).thenReturn(parentNodeRef); - when(mockedNodeService.getPrimaryParent(nodeRef)).thenReturn(mockedChildAssoc); - - Parameters mockedParameters = mock(Parameters.class); - Node mockedNodeInfo = mock(Node.class); - Map nodeProperties = new HashMap<>(); - nodeProperties.put("cm:title", "New Title"); - nodeProperties.put("cm:description", "New Description"); - when(mockedNodeInfo.getProperties()).thenReturn(nodeProperties); - - PropertyDefinition mockedPropertyDefinition = mock(PropertyDefinition.class); - when(mockedDictionaryService.getProperty(any(QName.class))).thenReturn(mockedPropertyDefinition); - - DataTypeDefinition mockedDataTypeDef = mock(DataTypeDefinition.class); - when(mockedPropertyDefinition.getDataType()).thenReturn(mockedDataTypeDef); - when(mockedDataTypeDef.getName()).thenReturn(AlfMock.generateQName()); - when(mockedNamespaceService.getNamespaceURI(any(String.class))).thenReturn(NamespaceService.CONTENT_MODEL_1_0_URI); - - when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true); - - Node updatedNode = rmNodesImpl.updateNode(nodeRef.getId(), mockedNodeInfo, mockedParameters); - assertNotNull(updatedNode); - - ArgumentCaptor propertiesMapCaptor = ArgumentCaptor.forClass(Map.class); - verify(mockedNodeService, times(1)).addProperties(eq(nodeRef), propertiesMapCaptor.capture()); - - // check property map - Map propertyMap = (Map)propertiesMapCaptor.getValue(); - assertNotNull(propertyMap); - assertEquals(2, propertyMap.size()); - assertTrue(propertyMap.containsKey(ContentModel.PROP_DESCRIPTION)); - assertTrue(propertyMap.containsKey(ContentModel.PROP_TITLE)); - - - //TODO have a look on this after RM-4295 is fixed -// assertEquals("New Description", updatedNode.getDescription()); -// assertEquals("New Title", updatedNode.getTitle()); - } - @Test public void testDeleteNode() throws Exception {