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

Classification enforcement refactor

Browse Source 
* added permission veto registry
 * extend permission service to check vetos before permission evaluation
 * register classification veto
 * unit and integration tests run
 * UI tests run



git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/modules/recordsmanagement/DEV/ROYTEST@109931 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Roy Wetherall
2015-08-12 04:57:37 +00:00
parent 2292b2a274
commit a239935668
29 changed files with 268 additions and 2090 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/classification/interceptor/processor/ArrayPostMethodInvocationProcessorUnitTest.java
View File

@@ -1,76 +0,0 @@
/*
* Copyright (C) 2005-2015 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.module.org_alfresco_module_rm.classification.interceptor.processor;
import static org.alfresco.service.cmr.repository.StoreRef.STORE_REF_WORKSPACE_SPACESSTORE;
import static org.alfresco.util.GUID.generate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import org.alfresco.service.cmr.repository.NodeRef;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
/**
* Array Post Method Invocation Processor Unit Test
*
* @author Tuna Aksoy
* @since 3.0.a
*/
public class ArrayPostMethodInvocationProcessorUnitTest
{
private static final NodeRef NODE_REF_1 = new NodeRef(STORE_REF_WORKSPACE_SPACESSTORE, generate());
private static final NodeRef NODE_REF_2 = new NodeRef(STORE_REF_WORKSPACE_SPACESSTORE, generate());
private static final NodeRef NODE_REF_3 = new NodeRef(STORE_REF_WORKSPACE_SPACESSTORE, generate());
private static final NodeRef NODE_REF_4 = new NodeRef(STORE_REF_WORKSPACE_SPACESSTORE, generate());
@InjectMocks private ArrayPostMethodInvocationProcessor arrayPostMethodInvocationProcessor;
@Mock private PostMethodInvocationProcessor mockedPostMethodInvocationProcessor;
@Mock private BasePostMethodInvocationProcessor mockedNodeRefProcessor;
@Before
public void setUp()
{
initMocks(this);
when(mockedPostMethodInvocationProcessor.getProcessor(isA(NodeRef.class))).thenReturn(mockedNodeRefProcessor);
when(mockedNodeRefProcessor.process(NODE_REF_1)).thenReturn(NODE_REF_1);
when(mockedNodeRefProcessor.process(NODE_REF_2)).thenReturn(null);
when(mockedNodeRefProcessor.process(NODE_REF_3)).thenReturn(NODE_REF_3);
when(mockedNodeRefProcessor.process(NODE_REF_4)).thenReturn(null);
}
@Test
public void testArrayPostMethodInvocationProcessor()
{
NodeRef[] nodes = new NodeRef[] { NODE_REF_1, NODE_REF_2, NODE_REF_3, NODE_REF_4 };
NodeRef[] processedNodes = arrayPostMethodInvocationProcessor.process(nodes);
assertEquals(2, processedNodes.length);
assertTrue(ArrayUtils.contains(processedNodes, NODE_REF_1));
assertTrue(ArrayUtils.contains(processedNodes, NODE_REF_3));
}
}

188
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/classification/interceptor/processor/CollectionPostMethodInvocationProcessorUnitTest.java
View File

@@ -1,188 +0,0 @@
/*
* Copyright (C) 2005-2015 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.module.org_alfresco_module_rm.classification.interceptor.processor;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Arrays.asList;
import static org.alfresco.util.GUID.generate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
/**
* Unit tests for the {@link CollectionPostMethodInvocationProcessor}.
*
* @author Tom Page
* @since 3.0.a
*/
public class CollectionPostMethodInvocationProcessorUnitTest
{
private static final String REALLY_LONG_OUTPUT_STRING = generate() + generate();
private static final String NON_FILTERED = generate();
private static final String FILTERED = generate();
@InjectMocks private CollectionPostMethodInvocationProcessor collectionPostMethodInvocationProcessor;
@Mock private PostMethodInvocationProcessor mockPostMethodInvocationProcessor;
@Mock private BasePostMethodInvocationProcessor mockStringProcessor;
@Before
public void setUp()
{
initMocks(this);
when(mockPostMethodInvocationProcessor.getProcessor(isA(List.class))).thenReturn(collectionPostMethodInvocationProcessor);
when(mockPostMethodInvocationProcessor.getProcessor(isA(String.class))).thenReturn(mockStringProcessor);
when(mockStringProcessor.process(REALLY_LONG_OUTPUT_STRING)).thenReturn(REALLY_LONG_OUTPUT_STRING);
when(mockStringProcessor.process(NON_FILTERED)).thenReturn(NON_FILTERED);
when(mockStringProcessor.process(FILTERED)).thenReturn(null);
}
@Test
public void testProcess_copesWithNull()
{
Object result = collectionPostMethodInvocationProcessor.process(null);
assertNull("Expected null collection to be passed through.", result);
}
@Test
public void testProcess_nullMember()
{
List<String> collection = new ArrayList<>();
collection.add(null);
Object result = collectionPostMethodInvocationProcessor.process(collection);
assertEquals("Expected collection containing null to be passed through.", collection, result);
}
@Test
public void testProcess_emptyList()
{
List<String> collection = new ArrayList<>();
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
assertEquals(collection, result);
}
@Test
public void testProcess_nonFilteredMember()
{
Object collection = asList(NON_FILTERED);
Object result = collectionPostMethodInvocationProcessor.process(collection);
assertEquals("Expected element to still be present in result.", collection, result);
}
@Test
public void testProcess_filteredMemberInModifiableList()
{
List<String> collection = newArrayList(FILTERED);
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
assertTrue("Expected an empty list.", result.isEmpty());
}
@Test(expected = UnsupportedOperationException.class)
public void testProcess_filteredMemberInUnmodifiableList()
{
List<String> collection = asList(FILTERED, NON_FILTERED);
collectionPostMethodInvocationProcessor.process(collection);
}
@Test
public void testProcess_noProcessorDefined()
{
List<Integer> collection = asList(1, 4, 91);
Collection<Integer> result = collectionPostMethodInvocationProcessor.process(collection);
assertEquals("If no processor is defined for the members then the whole list should be returned.", collection, result);
}
@SuppressWarnings("unchecked")
@Test
public void testProcess_listOfLists()
{
List<String> innerListA = newArrayList(FILTERED, NON_FILTERED);
List<String> innerListB = newArrayList(FILTERED, NON_FILTERED);
List<List<String>> collection = newArrayList(innerListA, innerListB);
Collection<List<String>> result = collectionPostMethodInvocationProcessor.process(collection);
List<String> expectedInnerListA = asList(NON_FILTERED);
List<String> expectedInnerListB = asList(NON_FILTERED);
List<List<String>> expected = asList(expectedInnerListA, expectedInnerListB);
assertEquals(expected, result);
}
/**
* Given I have a sorted set of input strings
* When I pass it to the collection processor
* Then I expect items above my clearance to be filtered
* And I expect items below my clearance to be passed through
* And I expect the output set to be sorted using the same comparator as the input.
*/
@Test
public void testProcess_sortedSet()
{
// Create a custom comparator that sorts based on the length of the strings.
Comparator<String> comparator = new Comparator<String>()
{
public int compare(String o1, String o2)
{
return o1.length() - o2.length();
}
};
SortedSet<String> collection = new TreeSet<>(comparator);
collection.add(REALLY_LONG_OUTPUT_STRING);
collection.add(NON_FILTERED);
collection.add(FILTERED);
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
Iterator<String> iterator = result.iterator();
assertEquals("Expected the first element to be the shortest", NON_FILTERED, iterator.next());
assertEquals("Expected the second element to be the longest", REALLY_LONG_OUTPUT_STRING, iterator.next());
assertFalse("Expected two elements in output", iterator.hasNext());
}
}

94
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/classification/interceptor/processor/NodeRefPostMethodInvocationProcessorUnitTest.java
View File

@@ -1,94 +0,0 @@
/*
* Copyright (C) 2005-2015 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.module.org_alfresco_module_rm.classification.interceptor.processor;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;
import static org.springframework.extensions.webscripts.GUID.generate;
import org.alfresco.module.org_alfresco_module_rm.classification.ContentClassificationService;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseUnitTest;
import org.alfresco.service.cmr.repository.NodeRef;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
/**
* NodeRef Post Method Invocation Processor Unit Test
*
* @author Tuna Aksoy
* @since 3.0.a
*/
public class NodeRefPostMethodInvocationProcessorUnitTest extends BaseUnitTest
{
@InjectMocks private NodeRefPostMethodInvocationProcessor nodeRefPostMethodInvocationProcessor;
@Mock private ContentClassificationService mockedContentClassificationService;
@Mock private PreMethodInvocationProcessor mockedPreMethodInvocationProcessor;
@Test
public void testProcessingNonExistingNode()
{
NodeRef nodeRef = new NodeRef(generate() + "://" + generate() + "/");
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef), TYPE_CONTENT)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef)).thenReturn(true);
assertEquals(nodeRef, nodeRefPostMethodInvocationProcessor.process(nodeRef));
}
@Test
public void testProcessingNonContent()
{
NodeRef nodeRef = generateNodeRef();
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef), TYPE_CONTENT)).thenReturn(false);
when(mockedContentClassificationService.hasClearance(nodeRef)).thenReturn(true);
assertEquals(nodeRef, nodeRefPostMethodInvocationProcessor.process(nodeRef));
}
@Test
public void testExistingNodeWithUserClearance()
{
NodeRef nodeRef = generateNodeRef();
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef), TYPE_CONTENT)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef)).thenReturn(true);
assertEquals(nodeRef, nodeRefPostMethodInvocationProcessor.process(nodeRef));
}
@Test
public void testExistingNodeWithNoUserClearance()
{
NodeRef nodeRef = generateNodeRef();
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef), TYPE_CONTENT)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef)).thenReturn(false);
assertEquals(null, nodeRefPostMethodInvocationProcessor.process(nodeRef));
}
@Test
public void testProcessingNull()
{
assertEquals("Expected null to be passed through without error.", null,
nodeRefPostMethodInvocationProcessor.process((NodeRef) null));
}
}

91
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/classification/interceptor/processor/QueryEngineResultsPostMethodInvocationProcessorUnitTest.java
View File

@@ -1,91 +0,0 @@
/*
* Copyright (C) 2005-2015 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.module.org_alfresco_module_rm.classification.interceptor.processor;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.alfresco.repo.search.impl.querymodel.QueryEngineResults;
import org.alfresco.service.cmr.search.ResultSet;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import com.google.common.collect.Sets;
/**
* Unit tests for {@link QueryEngineResultPostMethodInvocationProcessor}.
*
* @author Tom Page
* @since 3.0.a
*/
public class QueryEngineResultsPostMethodInvocationProcessorUnitTest
{
private static final Set<String> KEY_1 = Sets.newHashSet("KEY_1");
private static final Set<String> KEY_2 = Sets.newHashSet("KEY_2");
private static final Set<String> KEY_3 = Sets.newHashSet("KEY_3");
private static final Set<String> KEY_4 = Sets.newHashSet("KEY_4");
private static final ResultSet UNCLASSIFIED_RESULT_SET = mock(ResultSet.class);
private static final ResultSet CLASSIFIED_RESULT_SET = mock(ResultSet.class);
@InjectMocks
private QueryEngineResultsPostMethodInvocationProcessor processor = new QueryEngineResultsPostMethodInvocationProcessor();
@Mock
private PostMethodInvocationProcessor mockPostMethodInvocationProcessor;
@Mock
private ResultSetPostMethodInvocationProcessor mockResultSetPMIP;
@Before
public void setUp()
{
initMocks(this);
when(mockPostMethodInvocationProcessor.getProcessor(Mockito.any())).thenReturn(mockResultSetPMIP);
when(mockResultSetPMIP.process(UNCLASSIFIED_RESULT_SET)).thenReturn(UNCLASSIFIED_RESULT_SET);
when(mockResultSetPMIP.process(CLASSIFIED_RESULT_SET)).thenReturn(null);
}
/** Check that {@code process} filters out the classified result sets. */
@Test
public void testProcess()
{
Map<Set<String>, ResultSet> resultsMap = new HashMap<>();
resultsMap.put(KEY_1, UNCLASSIFIED_RESULT_SET);
resultsMap.put(KEY_2, CLASSIFIED_RESULT_SET);
resultsMap.put(KEY_3, UNCLASSIFIED_RESULT_SET);
resultsMap.put(KEY_4, CLASSIFIED_RESULT_SET);
QueryEngineResults queryEngineResults = new QueryEngineResults(resultsMap);
QueryEngineResults returnedQueryEngineResults = processor.process(queryEngineResults);
Map<Set<String>, ResultSet> expectedResultSet = new HashMap<>();
expectedResultSet.put(KEY_1, UNCLASSIFIED_RESULT_SET);
expectedResultSet.put(KEY_3, UNCLASSIFIED_RESULT_SET);
assertEquals("Unexpected results from query.", expectedResultSet, returnedQueryEngineResults.getResults());
}
}