inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-07-31 17:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Feature/rm 4639 rest api refactoring 2

Browse Source
This commit is contained in:
Tuna Aksoy
2017-04-12 07:36:12 +01:00
committed by Ramona Popa
parent 58bfcd5ccb
commit b244b56e7b
154 changed files with 18151 additions and 7134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/fileplancomponents/FileplanComponentChildrenRelationUnitTest.java
View File

@@ -1,107 +0,0 @@
/*
* #%L
* Alfresco Records Management Module
* %%
* Copyright (C) 2005 - 2017 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 <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.rm.rest.api.fileplancomponents;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
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.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<Node> nodeInfos = new ArrayList<Node>();
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 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);
}
}

121
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/fileplancomponents/FileplanComponentsEntityResourceUnitTest.java
View File

@@ -1,121 +0,0 @@
/*
* #%L
* Alfresco Records Management Module
* %%
* Copyright (C) 2005 - 2017 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 <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.rm.rest.api.fileplancomponents;
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);
}
}

292
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplRelativePathUnitTest.java
View File

@@ -1,292 +0,0 @@
/*
* #%L
* Alfresco Records Management Module
* %%
* Copyright (C) 2005 - 2017 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 <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.rm.rest.api.impl;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
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.model.ContentModel;
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.rest.api.model.Node;
import org.alfresco.service.cmr.model.FileInfo;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.namespace.NamespaceService;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
/**
* Unit Test class for RMNodesImpl.getOrCreatePath method
*
* @author Ana Bozianu
* @since 2.6
*/
public class RMNodesImplRelativePathUnitTest extends BaseUnitTest
{
@InjectMocks
private RMNodesImpl rmNodesImpl;
@Before
public void before()
{
MockitoAnnotations.initMocks(this);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_CATEGORY, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER)).thenReturn(false);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_CATEGORY, RecordsManagementModel.TYPE_UNFILED_RECORD_CONTAINER)).thenReturn(false);
when(mockedDictionaryService.isSubClass(ContentModel.TYPE_CONTENT, ContentModel.TYPE_CONTENT)).thenReturn(true);
when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, RecordsManagementModel.TYPE_UNFILED_RECORD_CONTAINER)).thenReturn(true);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, ContentModel.TYPE_CONTENT)).thenReturn(false);
when(mockedNamespaceService.getNamespaceURI(NamespaceService.CONTENT_MODEL_PREFIX)).thenReturn(NamespaceService.CONTENT_MODEL_1_0_URI);
when(mockedNamespaceService.getNamespaceURI(RM_PREFIX)).thenReturn(RM_URI);
}
/**
* Given any parent node
* When trying to create a node in the parent node with no relative path
* Then the parent node is returned and no node is created
*/
@Test
public void testNoRelativePath() throws Exception
{
/*
* Given any parent node
*/
NodeRef parentNode = AlfMock.generateNodeRef(mockedNodeService);
/*
* When trying to create a node in the parent node with no relative path
*/
Node nodeInfo = mock(Node.class);
NodeRef returnedPath = rmNodesImpl.getOrCreatePath(parentNode.getId(), null, ContentModel.TYPE_CONTENT);
/*
* Then the parent node is returned and no node is created
*/
assertEquals(parentNode, returnedPath);
verify(mockedFileFolderService, never()).create(any(), any(), any());
verify(mockedFilePlanService, never()).createRecordCategory(any(), any());
}
/**
* Given a parent node and an existing path c1/f1 under it
* When trying to create a node in the parent node with the relative path c1/f1
* Then the node f1 is returned and no node is created
*/
@Test
public void testGetExistingRelativePath() throws Exception
{
/*
* Given a parent node and an existing path c1/f1 under it
*/
NodeRef parentNode = AlfMock.generateNodeRef(mockedNodeService);
String category = "c1";
NodeRef categoryNode = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getChildByName(parentNode, ContentModel.ASSOC_CONTAINS, category)).thenReturn(categoryNode);
String recordFolder = "f1";
NodeRef recordFolderNode = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getChildByName(categoryNode, ContentModel.ASSOC_CONTAINS, recordFolder)).thenReturn(recordFolderNode);
/*
* When trying to create a node in the parent node with the relative path c1/f1
*/
Node nodeInfo = mock(Node.class);
NodeRef returnedPath = rmNodesImpl.getOrCreatePath(parentNode.getId(), category + "/" + recordFolder, ContentModel.TYPE_CONTENT);
/*
* Then the node f1 is returned and no node is created
*/
assertEquals(recordFolderNode, returnedPath);
verify(mockedFileFolderService, never()).create(any(), any(), any());
verify(mockedFilePlanService, never()).createRecordCategory(any(), any());
}
/**
* Given the fileplan and an existing path c1/c2 under fileplan
* When creating a content node under fileplan with the relative path c1/c2/c3/f1
* Then the category c3 and the record folder f1 should be created and f1 should be returned
*
* @throws Exception
*/
@Test
public void testCreatePartiallyExistingRelativePath() throws Exception
{
/*
* Given the fileplan and an existing path c1/c2 under fileplan
*/
NodeRef fileplanNodeRef = AlfMock.generateNodeRef(mockedNodeService);
// create c1
String category1 = "c1";
NodeRef categoryNode1 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getChildByName(fileplanNodeRef, ContentModel.ASSOC_CONTAINS, category1)).thenReturn(categoryNode1);
// create c2
String category2 = "c2";
NodeRef categoryNode2 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getChildByName(categoryNode1, ContentModel.ASSOC_CONTAINS, category2)).thenReturn(categoryNode2);
when(mockedNodeService.getType(categoryNode2)).thenReturn(TYPE_RECORD_CATEGORY);
/*
* When trying to create a content node in the relative path c1/c2/c3/f1
*/
// c3
String category3 = "c3";
NodeRef categoryNode3 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.createRecordCategory(categoryNode2, category3)).thenReturn(categoryNode3);
// f1
String recordFolder = "f1";
NodeRef recordFolderNode = AlfMock.generateNodeRef(mockedNodeService);
FileInfo recordFolderFileInfo = mock(FileInfo.class);
when(recordFolderFileInfo.getNodeRef()).thenReturn(recordFolderNode);
when(mockedFileFolderService.create(categoryNode3, recordFolder, RecordsManagementModel.TYPE_RECORD_FOLDER)).thenReturn(recordFolderFileInfo);
// call the class under tests
NodeRef returnedPath = rmNodesImpl.getOrCreatePath(fileplanNodeRef.getId(), category1 + "/" + category2 + "/" + category3 + "/" + recordFolder, ContentModel.TYPE_CONTENT);
/*
* Then the category c1 and the record folder f1 should be created and f1 should be returned
*/
assertEquals(recordFolderNode, returnedPath);
verify(mockedFilePlanService, times(1)).createRecordCategory(categoryNode2, category3);
verify(mockedFileFolderService, times(1)).create(categoryNode3, recordFolder, RecordsManagementModel.TYPE_RECORD_FOLDER);
}
/**
* Given the unfiled record container
* When creating a content node under fileplan with the relative path f1/f2/f3
* Then the 3 unfiled record folders should be created and f3 should be returned
*/
@Test
public void testCreateRelativePathInUnfiledRecords() throws Exception
{
/*
* Given the unfiled record folder
*/
NodeRef unfiledRecordContainer = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getType(unfiledRecordContainer)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
/*
* When trying to create a content node in the relative path f1/f2/f3
*/
// f1
String folder1 = "f1";
NodeRef folderNode1 = AlfMock.generateNodeRef(mockedNodeService);
FileInfo folderFileInfo1 = mock(FileInfo.class);
when(folderFileInfo1.getNodeRef()).thenReturn(folderNode1);
when(mockedFileFolderService.create(unfiledRecordContainer, folder1, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER)).thenReturn(folderFileInfo1);
// f2
String folder2 = "f2";
NodeRef folderNode2 = AlfMock.generateNodeRef(mockedNodeService);
FileInfo folderFileInfo2 = mock(FileInfo.class);
when(folderFileInfo2.getNodeRef()).thenReturn(folderNode2);
when(mockedFileFolderService.create(folderNode1, folder2, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER)).thenReturn(folderFileInfo2);
// f3
String folder3 = "f3";
NodeRef folderNode3 = AlfMock.generateNodeRef(mockedNodeService);
FileInfo folderFileInfo3 = mock(FileInfo.class);
when(folderFileInfo3.getNodeRef()).thenReturn(folderNode3);
when(mockedFileFolderService.create(folderNode2, folder3, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER)).thenReturn(folderFileInfo3);
// call the class under tests
NodeRef returnedParentNode = rmNodesImpl.getOrCreatePath(unfiledRecordContainer.getId(), folder1 + "/" + folder2 + "/" + folder3, ContentModel.TYPE_CONTENT);
/*
* Then the category c1 and the record folder rf1 should be created
* and an instance to the record folder should be returned
*/
assertEquals(folderNode3, returnedParentNode);
verify(mockedFileFolderService, times(1)).create(unfiledRecordContainer, folder1, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER);
verify(mockedFileFolderService, times(1)).create(folderNode1, folder2, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER);
verify(mockedFileFolderService, times(1)).create(folderNode2, folder3, RecordsManagementModel.TYPE_UNFILED_RECORD_FOLDER);
//check no other node is created
verify(mockedFilePlanService, never()).createRecordCategory(any(), any());
verify(mockedFileFolderService, times(3)).create(any(), any(), any());
}
/**
* Given the fileplan
* When creating a record folder node under fileplan with the relative path c1/c2/c3
* Then the categories c1, c2 and c3 should be created and c3 should be returned
*/
@Test
public void testCreateRelativePathToRecordFolder() throws Exception
{
/*
* Given the fileplan
*/
NodeRef fileplanNodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getType(fileplanNodeRef)).thenReturn(TYPE_FILE_PLAN);
/*
* When trying to create a folder node in the relative path c1/c2/c3
*/
// c1
String category1 = "c1";
NodeRef categoryNode1 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.createRecordCategory(fileplanNodeRef, category1)).thenReturn(categoryNode1);
// c2
String category2 = "c2";
NodeRef categoryNode2 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.createRecordCategory(categoryNode1, category2)).thenReturn(categoryNode2);
// c3
String category3 = "c3";
NodeRef categoryNode3 = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.createRecordCategory(categoryNode2, category3)).thenReturn(categoryNode3);
// call the class under tests
NodeRef returnedParentNode = rmNodesImpl.getOrCreatePath(fileplanNodeRef.getId(), category1 + "/" + category2 + "/" + category3, RecordsManagementModel.TYPE_RECORD_FOLDER);
/*
* Then the categories c1, c2 and c3 should be created and c3 should be returned
*/
assertEquals(categoryNode3, returnedParentNode);
verify(mockedFilePlanService, times(1)).createRecordCategory(fileplanNodeRef, category1);
verify(mockedFilePlanService, times(1)).createRecordCategory(categoryNode1, category2);
verify(mockedFilePlanService, times(1)).createRecordCategory(categoryNode2, category3);
// check no other node is created
verify(mockedFilePlanService, times(3)).createRecordCategory(any(), any());
verify(mockedFileFolderService, never()).create(any(), any(), any());
}
}

671
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMNodesImplUnitTest.java
View File

@@ -1,671 +0,0 @@
/*
* #%L
* Alfresco Records Management Module
* %%
* Copyright (C) 2005 - 2017 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 <http://www.gnu.org/licenses/>.
* #L%
*/
package org.alfresco.rm.rest.api.impl;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.List;
import org.alfresco.model.ContentModel;
import org.alfresco.module.org_alfresco_module_rm.capability.Capability;
import org.alfresco.module.org_alfresco_module_rm.capability.CapabilityService;
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.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.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.SiteService;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import net.sf.acegisecurity.vote.AccessDecisionVoter;
/**
* 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;
@Mock
private CapabilityService mockedCapabilityService;
@InjectMocks
private RMNodesImpl rmNodesImpl;
private Capability deleteCapability;
private Capability createCapability;
private Capability updateCapability;
@Before
public void before()
{
MockitoAnnotations.initMocks(this);
List<String> prefixes = new ArrayList<String>();
prefixes.add(NamespaceService.DEFAULT_PREFIX);
when(mockedNamespaceService.getPrefixes(any(String.class))).thenReturn(prefixes);
when(mockedNamespaceService.getNamespaceURI(any(String.class))).thenReturn(RM_URI);
deleteCapability = mock(Capability.class);
when(mockedCapabilityService.getCapability("Delete")).thenReturn(deleteCapability);
createCapability = mock(Capability.class);
when(mockedCapabilityService.getCapability("FillingPermissionOnly")).thenReturn(createCapability);
updateCapability = mock(Capability.class);
when(mockedCapabilityService.getCapability("Update")).thenReturn(updateCapability);
}
@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);
setupCompanyHomeAndPrimaryParent(nodeRef);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
List<String> includeParamList = new ArrayList<String>();
includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS);
setPermissions(nodeRef, AccessStatus.ALLOWED);
when(deleteCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(createCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(updateCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(nodeRef);
Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null);
checksAllowedOperations(folderOrDocument, true, true, false);
}
@Test
public void testGetFilePlanAllowableOperationsWithoutPermissions() 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);
setupCompanyHomeAndPrimaryParent(nodeRef);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
List<String> includeParamList = new ArrayList<String>();
includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS);
setPermissions(nodeRef, AccessStatus.DENIED);
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<String> allowableOperations = resultNode.getAllowableOperations();
assertNull(allowableOperations);
}
@Test
public void testGetTransferContainerAllowableOperations() throws Exception
{
NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_TRANSFER_CONTAINER);
when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_TRANSFER_CONTAINER, ContentModel.TYPE_FOLDER)).thenReturn(true);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS);
setPermissions(nodeRef, AccessStatus.ALLOWED);
NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef);
when(mockedFilePlanService.getTransferContainer(filePlanNodeRef)).thenReturn(nodeRef);
when(deleteCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(createCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(updateCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null);
checksAllowedOperations(folderOrDocument, false, true, false);
}
@Test
public void testGetHoldContainerAllowableOperations() throws Exception
{
NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_HOLD_CONTAINER);
when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_HOLD_CONTAINER, ContentModel.TYPE_FOLDER)).thenReturn(true);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS);
setPermissions(nodeRef, 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);
when(deleteCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(createCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(updateCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null);
checksAllowedOperations(folderOrDocument, true, true, false);
}
@Test
public void testGetUnfiledContainerAllowableOperations() throws Exception
{
NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodeService.getType(nodeRef)).thenReturn(RecordsManagementModel.TYPE_UNFILED_RECORD_CONTAINER);
when(mockedDictionaryService.isSubClass(RecordsManagementModel.TYPE_UNFILED_RECORD_CONTAINER, ContentModel.TYPE_FOLDER)).thenReturn(true);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
includeParamList.add(RMNodes.PARAM_INCLUDE_ALLOWABLEOPERATIONS);
setPermissions(nodeRef, 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);
when(deleteCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(createCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(updateCapability.evaluate(nodeRef)).thenReturn(AccessDecisionVoter.ACCESS_GRANTED);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(true);
Node folderOrDocument = rmNodesImpl.getFolderOrDocument(nodeRef, null, null, includeParamList, null);
checksAllowedOperations(folderOrDocument, true, true, false);
}
@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);
setupCompanyHomeAndPrimaryParent(nodeRef);
when(mockedFilePlanService.isFilePlanComponent(nodeRef)).thenReturn(false);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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);
setupCompanyHomeAndPrimaryParent(nodeRef);
List<String> includeParamList = new ArrayList<String>();
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 testValidateNodeWithFilePlanAlias() throws Exception
{
NodeRef filePlanNodeRef = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(filePlanNodeRef);
NodeRef validateOrLookupNode = rmNodesImpl.validateNode(FILE_PLAN_ALIAS);
assertEquals(filePlanNodeRef, validateOrLookupNode);
}
@Test
public void testValidateNodeWithTransfersAlias() 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.validateNode(TRANSFERS_ALIAS);
assertEquals(transferContainerNodeRef, validateOrLookupNode);
}
@Test
public void testValidateNodeWithHoldsAlias() 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.validateNode(HOLDS_ALIAS);
assertEquals(holdsContainerNodeRef, validateOrLookupNode);
}
@Test
public void testValidateNodeWithUnfiledAlias() 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.validateNode(UNFILED_ALIAS);
assertEquals(unfiledContainerNodeRef, validateOrLookupNode);
}
@Test
public void testValidateNodeWithFilePlanAliasRMSiteNotCreated() throws Exception
{
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null);
try
{
rmNodesImpl.validateNode(FILE_PLAN_ALIAS);
fail("Expected exception as RM site is not created.");
}
catch(EntityNotFoundException ex)
{
//it is ok since exception is thrown
}
}
@Test
public void testValidateNodeWithTransferAliasRMSiteNotCreated() throws Exception
{
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null);
try
{
rmNodesImpl.validateNode(TRANSFERS_ALIAS);
fail("Expected exception as RM site is not created.");
}
catch(EntityNotFoundException ex)
{
//it is ok since exception is thrown
}
}
@Test
public void testValidateNodeWithHoldsAliasRMSiteNotCreated() throws Exception
{
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null);
try
{
rmNodesImpl.validateNode(HOLDS_ALIAS);
fail("Expected exception as RM site is not created.");
}
catch(EntityNotFoundException ex)
{
//it is ok since exception is thrown
}
}
@Test
public void testValidateNodeWithUnfiledAliasRMSiteNotCreated() throws Exception
{
when(mockedFilePlanService.getFilePlanBySiteId(RM_SITE_ID)).thenReturn(null);
try
{
rmNodesImpl.validateNode(UNFILED_ALIAS);
fail("Expected exception as RM site is not created.");
}
catch(EntityNotFoundException ex)
{
//it is ok since exception is thrown
}
}
@Test
public void testValidateNodeNullNodeRef() throws Exception
{
try
{
rmNodesImpl.validateNode((String)null);
fail("Expected exception as nodId should not be null or empty.");
}
catch(IllegalArgumentException ex)
{
assertEquals("nodeId is a mandatory parameter", ex.getMessage());
}
}
@Test
public void testValidateNode() throws Exception
{
NodeRef nodeRef = AlfMock.generateNodeRef(mockedNodeService);
NodeRef validateOrLookupNode = rmNodesImpl.validateNode(nodeRef.getId());
assertEquals(nodeRef, validateOrLookupNode);
}
private void setupCompanyHomeAndPrimaryParent(NodeRef nodeRef)
{
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);
}
private void setPermissions(NodeRef nodeRef, AccessStatus permissionToSet)
{
when(mockedPermissionService.hasPermission(nodeRef, PermissionService.WRITE)).thenReturn(permissionToSet);
when(mockedPermissionService.hasPermission(nodeRef, PermissionService.DELETE)).thenReturn(permissionToSet);
when(mockedPermissionService.hasPermission(nodeRef, PermissionService.ADD_CHILDREN)).thenReturn(permissionToSet);
}
private void checksAllowedOperations(Node containerNode, boolean allowCreate, boolean allowUpdate, boolean allowDelete)
{
assertNotNull(containerNode);
assertTrue(FileplanComponentNode.class.isInstance(containerNode));
FileplanComponentNode resultNode = (FileplanComponentNode) containerNode;
List<String> allowableOperations = resultNode.getAllowableOperations();
assertEquals("Create operation should " + (allowCreate?"":"not ") + "be available for provided container.",
allowCreate,
allowableOperations.contains(RMNodes.OP_CREATE));
assertEquals("Update operation should " + (allowCreate?"":"not ") + "be available for provided container.",
allowUpdate,
allowableOperations.contains(RMNodes.OP_UPDATE));
assertEquals("Delete operation should " + (allowCreate?"":"not ") + "be available for provided container.",
allowDelete,
allowableOperations.contains(RMNodes.OP_DELETE));
}
}

5
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RMSitesImplUnitTest.java
View File

@@ -43,10 +43,11 @@ 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.security.authentication.AuthenticationUtil;
import org.alfresco.rest.api.impl.SiteImportPackageHandler;
import org.alfresco.rest.api.model.Site;
import org.alfresco.rest.api.model.SiteUpdate;
import org.alfresco.rest.framework.resource.parameters.Parameters;
import org.alfresco.rm.rest.api.model.RMSite;
import org.alfresco.rm.rest.api.model.RMSiteCompliance;
import org.alfresco.rm.rest.api.model.SiteUpdate;
import org.alfresco.service.cmr.favourites.FavouritesService;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.site.SiteInfo;
@@ -259,6 +260,8 @@ public class RMSitesImplUnitTest extends BaseUnitTest
when(mockedSiteUpdate.getDescription()).thenReturn(RM_SITE_DESCRIPTION_AFTER_UPDATE);
when(mockedSiteUpdate.getTitle()).thenReturn(RM_SITE_TITLE_AFTER_UPDATE);
when(mockedSiteUpdate.getVisibility()).thenReturn(null);
when(mockedSiteUpdate.wasSet(Site.TITLE)).thenReturn(true);
when(mockedSiteUpdate.wasSet(Site.DESCRIPTION)).thenReturn(true);
//mock Parameters
Parameters mockedParameters = mock(Parameters.class);

542
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/impl/RecordsImplUnitTest.java
View File

@@ -41,8 +41,6 @@ import org.alfresco.module.org_alfresco_module_rm.test.util.AlfMock;
import org.alfresco.module.org_alfresco_module_rm.test.util.MockAuthenticationUtilHelper;
import org.alfresco.module.org_alfresco_module_rm.util.AuthenticationUtil;
import org.alfresco.rest.framework.resource.parameters.Parameters;
import org.alfresco.rm.rest.api.RMNodes;
import org.alfresco.rm.rest.api.Records;
import org.alfresco.rm.rest.api.model.TargetContainer;
import org.alfresco.service.cmr.dictionary.DictionaryService;
import org.alfresco.service.cmr.model.FileFolderService;
@@ -64,274 +62,274 @@ import org.mockito.MockitoAnnotations;
*/
public class RecordsImplUnitTest
{
@Mock
private RecordService mockedRecordService;
@Mock
protected FilePlanService mockedFilePlanService;
@Mock
protected NodeService mockedNodeService;
@Mock
protected FileFolderService mockedFileFolderService;
@Mock
protected DictionaryService mockedDictionaryService;
@Mock
protected AuthenticationUtil mockedAuthenticationUtil;
@Mock
protected RMNodes mockedNodes;
@InjectMocks
private RecordsImpl recordsImpl;
@Before
public void before()
{
MockitoAnnotations.initMocks(this);
// setup mocked authentication util
MockAuthenticationUtilHelper.setup(mockedAuthenticationUtil);
}
/**
* Given a file and an existing fileplan
* When declaring a file as record
* Then a record is created under the existing fileplan from the provided file
*/
@Test
public void testDeclareFileAsRecord()
{
/*
* Given a file and an existing fileplan
*/
NodeRef mockedFile = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedFile.getId())).thenReturn(mockedFile);
NodeRef fileplan = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID)).thenReturn(fileplan);
/*
* When declare the file as record
*/
Parameters params = Mockito.mock(Parameters.class);
when(params.getParameter(Records.PARAM_HIDE_RECORD)).thenReturn("true");
recordsImpl.declareFileAsRecord(mockedFile.getId(), params);
/*
* Then a record is created under the existing fileplan from the provided file
*/
verify(mockedRecordService).createRecord(fileplan, mockedFile, false);
verify(mockedNodes).getFolderOrDocument(mockedFile.getId(), params);
}
/**
* Given a record
* When trying to filing a record providing a blank destination path
* Then an InvalidParameterException is thrown
*/
@Test(expected=InvalidParameterException.class)
public void testFileRecord_BlankDestinationPath()
{
/*
* Given a record
*/
NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
/*
* When trying to filing a record providing a blank destination path
*/
Parameters params = Mockito.mock(Parameters.class);
TargetContainer target = new TargetContainer();
recordsImpl.fileOrLinkRecord(mockedRecord.getId(), target, params);
}
/**
* Given an unfiled record and an existing record folder
* When trying to file the record in the record folder
* Then the record is moved under the destination folder
*/
@Test
public void testFileRecord_DestinationById() throws Exception
{
/*
* Given an unfiled record and an existing record folder
*/
// mock the record to file
NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
// mock the current primary parent
NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
// mock the target record folder to file the record into
NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
/*
* When trying to file the record in the record folder
*/
TargetContainer destination = new TargetContainer();
destination.setTargetParentId(mockedTargetRecordFolder.getId());
Parameters params = Mockito.mock(Parameters.class);
recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
/*
* Then the record is moved under the destination folder
*/
verify(mockedNodes).getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT);
verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
}
/**
* Given an unfiled record
* and an existing record folder with relative path category/recordFolder from fileplan
* When trying to file the record using a relative path and no target id
* Then the record is moved under the destination folder relative to the fileplan
*/
@Test
public void testFileRecord_DestinationRelativeToFileplan() throws Exception
{
/*
* Given an unfiled record and an existing record folder
*/
// mock the record to file
NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
// mock the current primary parent
NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
// mock the fileplan
NodeRef fileplan = AlfMock.generateNodeRef(mockedNodeService);
when(mockedFilePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID)).thenReturn(fileplan);
// mock the target record folder to file the record into
String relativePath = "category/recordFolder";
NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.getOrCreatePath(fileplan.getId(), relativePath, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
/*
* When trying to file the record using a relative path and no target id
*/
TargetContainer destination = new TargetContainer();
destination.setRelativePath(relativePath);
Parameters params = Mockito.mock(Parameters.class);
recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
/*
* Then the record is moved under the destination folder relative to the fileplan
*/
verify(mockedNodes).getOrCreatePath(fileplan.getId(), relativePath, TYPE_CONTENT);
verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
}
/**
* Given an unfiled record
* and an existing record folder with relative path category/recordFolder from a given category
* When trying to file the record describing the target folder with the category id and the relative path
* Then the record is moved under the correct destination folder
*/
@Test
public void testFileRecord_DestinationRelativeToProvidedId() throws Exception
{
/*
* Given an unfiled record and an existing record folder with relative path category/recordFolder from a given category
*/
// mock the record to file
NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
// mock the current primary parent
NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
// mock the target category
NodeRef mockedTargetCategory = AlfMock.generateNodeRef(mockedNodeService);
// mock the target record folder to file the record into
String relativePath = "category/recordFolder";
NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.getOrCreatePath(mockedTargetCategory.getId(), relativePath, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
/*
* When trying to file the record describing the target folder with the category id and the relative path
*/
TargetContainer destination = new TargetContainer();
destination.setTargetParentId(mockedTargetCategory.getId());
destination.setRelativePath(relativePath);
Parameters params = Mockito.mock(Parameters.class);
recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
/*
* Then the record is moved under the correct destination folder
*/
verify(mockedNodes).getOrCreatePath(mockedTargetCategory.getId(), relativePath, TYPE_CONTENT);
verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
}
/**
* Given an filed record and an existing record folder
* When trying to link the record to the record folder
* Then the record is linked to the destination folder
*/
@Test
public void testLinkRecord()
{
/*
* Given an filed record and an existing record folder
*/
// mock the record to link
NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
// mock the current primary parent
NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_RECORD_FOLDER);
when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
// mock the target record folder to file the record into
NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
when(mockedNodes.getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
/*
* When trying to link the record to the record folder
*/
TargetContainer destination = new TargetContainer();
destination.setTargetParentId(mockedTargetRecordFolder.getId());
Parameters params = Mockito.mock(Parameters.class);
recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
/*
* Then the record is linked to the destination folder
*/
verify(mockedNodes).getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT);
verify(mockedRecordService).link(mockedRecord, mockedTargetRecordFolder);
}
// @Mock
// private RecordService mockedRecordService;
// @Mock
// protected FilePlanService mockedFilePlanService;
// @Mock
// protected NodeService mockedNodeService;
// @Mock
// protected FileFolderService mockedFileFolderService;
// @Mock
// protected DictionaryService mockedDictionaryService;
// @Mock
// protected AuthenticationUtil mockedAuthenticationUtil;
// @Mock
// protected RMNodes mockedNodes;
//
// @InjectMocks
// private RecordsImpl recordsImpl;
//
// @Before
// public void before()
// {
// MockitoAnnotations.initMocks(this);
//
// // setup mocked authentication util
// MockAuthenticationUtilHelper.setup(mockedAuthenticationUtil);
// }
//
// /**
// * Given a file and an existing fileplan
// * When declaring a file as record
// * Then a record is created under the existing fileplan from the provided file
// */
// @Test
// public void testDeclareFileAsRecord()
// {
// /*
// * Given a file and an existing fileplan
// */
// NodeRef mockedFile = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedFile.getId())).thenReturn(mockedFile);
//
// NodeRef fileplan = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedFilePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID)).thenReturn(fileplan);
//
// /*
// * When declare the file as record
// */
// Parameters params = Mockito.mock(Parameters.class);
// when(params.getParameter(Records.PARAM_HIDE_RECORD)).thenReturn("true");
// recordsImpl.declareFileAsRecord(mockedFile.getId(), params);
//
// /*
// * Then a record is created under the existing fileplan from the provided file
// */
// verify(mockedRecordService).createRecord(fileplan, mockedFile, false);
// verify(mockedNodes).getFolderOrDocument(mockedFile.getId(), params);
// }
//
// /**
// * Given a record
// * When trying to filing a record providing a blank destination path
// * Then an InvalidParameterException is thrown
// */
// @Test(expected=InvalidParameterException.class)
// public void testFileRecord_BlankDestinationPath()
// {
// /*
// * Given a record
// */
// NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
//
// /*
// * When trying to filing a record providing a blank destination path
// */
// Parameters params = Mockito.mock(Parameters.class);
// TargetContainer target = new TargetContainer();
// recordsImpl.fileOrLinkRecord(mockedRecord.getId(), target, params);
// }
//
// /**
// * Given an unfiled record and an existing record folder
// * When trying to file the record in the record folder
// * Then the record is moved under the destination folder
// */
// @Test
// public void testFileRecord_DestinationById() throws Exception
// {
// /*
// * Given an unfiled record and an existing record folder
// */
// // mock the record to file
// NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
//
// // mock the current primary parent
// NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
// ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
// when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
// when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
// when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
// when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
//
// // mock the target record folder to file the record into
// NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
// when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
// when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
//
// /*
// * When trying to file the record in the record folder
// */
// TargetContainer destination = new TargetContainer();
// destination.setTargetParentId(mockedTargetRecordFolder.getId());
//
// Parameters params = Mockito.mock(Parameters.class);
// recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
//
// /*
// * Then the record is moved under the destination folder
// */
// verify(mockedNodes).getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT);
// verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
// }
//
// /**
// * Given an unfiled record
// * and an existing record folder with relative path category/recordFolder from fileplan
// * When trying to file the record using a relative path and no target id
// * Then the record is moved under the destination folder relative to the fileplan
// */
// @Test
// public void testFileRecord_DestinationRelativeToFileplan() throws Exception
// {
// /*
// * Given an unfiled record and an existing record folder
// */
// // mock the record to file
// NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
//
// // mock the current primary parent
// NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
// ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
// when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
// when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
// when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
// when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
//
// // mock the fileplan
// NodeRef fileplan = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedFilePlanService.getFilePlanBySiteId(FilePlanService.DEFAULT_RM_SITE_ID)).thenReturn(fileplan);
//
// // mock the target record folder to file the record into
// String relativePath = "category/recordFolder";
// NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.getOrCreatePath(fileplan.getId(), relativePath, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
// when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
// when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
//
// /*
// * When trying to file the record using a relative path and no target id
// */
// TargetContainer destination = new TargetContainer();
// destination.setRelativePath(relativePath);
//
// Parameters params = Mockito.mock(Parameters.class);
// recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
//
// /*
// * Then the record is moved under the destination folder relative to the fileplan
// */
// verify(mockedNodes).getOrCreatePath(fileplan.getId(), relativePath, TYPE_CONTENT);
// verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
// }
//
// /**
// * Given an unfiled record
// * and an existing record folder with relative path category/recordFolder from a given category
// * When trying to file the record describing the target folder with the category id and the relative path
// * Then the record is moved under the correct destination folder
// */
// @Test
// public void testFileRecord_DestinationRelativeToProvidedId() throws Exception
// {
// /*
// * Given an unfiled record and an existing record folder with relative path category/recordFolder from a given category
// */
// // mock the record to file
// NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
//
// // mock the current primary parent
// NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
// ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
// when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
// when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
// when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_UNFILED_RECORD_CONTAINER);
// when(mockedDictionaryService.isSubClass(TYPE_UNFILED_RECORD_CONTAINER, TYPE_RECORD_FOLDER)).thenReturn(false);
//
// // mock the target category
// NodeRef mockedTargetCategory = AlfMock.generateNodeRef(mockedNodeService);
//
// // mock the target record folder to file the record into
// String relativePath = "category/recordFolder";
// NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.getOrCreatePath(mockedTargetCategory.getId(), relativePath, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
// when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
// when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
//
// /*
// * When trying to file the record describing the target folder with the category id and the relative path
// */
// TargetContainer destination = new TargetContainer();
// destination.setTargetParentId(mockedTargetCategory.getId());
// destination.setRelativePath(relativePath);
//
// Parameters params = Mockito.mock(Parameters.class);
// recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
//
// /*
// * Then the record is moved under the correct destination folder
// */
// verify(mockedNodes).getOrCreatePath(mockedTargetCategory.getId(), relativePath, TYPE_CONTENT);
// verify(mockedFileFolderService).moveFrom(mockedRecord, mockedPrimaryParent, mockedTargetRecordFolder, null);
// }
//
// /**
// * Given an filed record and an existing record folder
// * When trying to link the record to the record folder
// * Then the record is linked to the destination folder
// */
// @Test
// public void testLinkRecord()
// {
// /*
// * Given an filed record and an existing record folder
// */
// // mock the record to link
// NodeRef mockedRecord = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.validateNode(mockedRecord.getId())).thenReturn(mockedRecord);
//
// // mock the current primary parent
// NodeRef mockedPrimaryParent = AlfMock.generateNodeRef(mockedNodeService);
// ChildAssociationRef mockedChildAssoc = mock(ChildAssociationRef.class);
// when(mockedChildAssoc.getParentRef()).thenReturn(mockedPrimaryParent);
// when(mockedNodeService.getPrimaryParent(mockedRecord)).thenReturn(mockedChildAssoc);
// when(mockedNodeService.getType(mockedPrimaryParent)).thenReturn(TYPE_RECORD_FOLDER);
// when(mockedDictionaryService.isSubClass(TYPE_RECORD_FOLDER, TYPE_RECORD_FOLDER)).thenReturn(true);
//
// // mock the target record folder to file the record into
// NodeRef mockedTargetRecordFolder = AlfMock.generateNodeRef(mockedNodeService);
// when(mockedNodes.getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT)).thenReturn(mockedTargetRecordFolder);
// when(mockedNodeService.getType(mockedTargetRecordFolder)).thenReturn(TYPE_RECORD_FOLDER);
//
// /*
// * When trying to link the record to the record folder
// */
// TargetContainer destination = new TargetContainer();
// destination.setTargetParentId(mockedTargetRecordFolder.getId());
//
// Parameters params = Mockito.mock(Parameters.class);
// recordsImpl.fileOrLinkRecord(mockedRecord.getId(), destination, params);
//
// /*
// * Then the record is linked to the destination folder
// */
// verify(mockedNodes).getOrCreatePath(mockedTargetRecordFolder.getId(), null, TYPE_CONTENT);
// verify(mockedRecordService).link(mockedRecord, mockedTargetRecordFolder);
// }
}

39
rm-community/rm-community-repo/unit-test/java/org/alfresco/rm/rest/api/sites/RMSiteEntityResourceUnitTest.java
View File

@@ -30,26 +30,6 @@ package org.alfresco.rm.rest.api.sites;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.List;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest;
import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException;
import org.alfresco.rest.framework.resource.parameters.Parameters;
import org.alfresco.rest.framework.resource.parameters.Params;
import org.alfresco.rm.rest.api.RMSites;
import org.alfresco.rm.rest.api.model.RMSite;
import org.alfresco.rm.rest.api.model.RMSiteCompliance;
import org.alfresco.rm.rest.api.model.SiteUpdate;
import org.alfresco.service.cmr.site.SiteVisibility;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -57,6 +37,25 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.List;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest;
import org.alfresco.rest.api.model.SiteUpdate;
import org.alfresco.rest.framework.core.exceptions.InvalidArgumentException;
import org.alfresco.rest.framework.resource.parameters.Parameters;
import org.alfresco.rest.framework.resource.parameters.Params;
import org.alfresco.rm.rest.api.RMSites;
import org.alfresco.rm.rest.api.model.RMSite;
import org.alfresco.rm.rest.api.model.RMSiteCompliance;
import org.alfresco.service.cmr.site.SiteVisibility;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
/**
* Unit Test class for RMSiteEntityResource.
*