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

RM-2130 (Check classification after method execution, filtering results where appropriate)

Browse Source 
- Code refactored

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/modules/recordsmanagement/HEAD@107441 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Tuna Aksoy
2015-06-30 19:15:27 +00:00
parent fa3f1230a4
commit ea4d00f100
19 changed files with 145 additions and 580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,18 +18,20 @@
*/
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.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.apache.commons.lang3.ArrayUtils;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
/**
* Array Post Method Invocation Processor Unit Test
@@ -37,40 +39,38 @@ import org.mockito.Mockito;
* @author Tuna Aksoy
* @since 3.0
*/
public class ArrayPostMethodInvocationProcessorUnitTest extends BaseUnitTest
public class ArrayPostMethodInvocationProcessorUnitTest
{
@InjectMocks ArrayPostMethodInvocationProcessor arrayPostMethodInvocationProcessor;
@Mock private ContentClassificationService mockedContentClassificationService;
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()
{
NodeRefPostMethodInvocationProcessor processor = new NodeRefPostMethodInvocationProcessor();
processor.setNodeService(mockedNodeService);
processor.setDictionaryService(mockedDictionaryService);
processor.setContentClassificationService(mockedContentClassificationService);
NodeRef nodeRef1 = generateNodeRef();
NodeRef nodeRef2 = generateNodeRef();
NodeRef nodeRef3 = generateNodeRef();
NodeRef nodeRef4 = generateNodeRef();
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef1), TYPE_CONTENT)).thenReturn(true);
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef2), TYPE_CONTENT)).thenReturn(true);
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef3), TYPE_CONTENT)).thenReturn(true);
when(mockedDictionaryService.isSubClass(mockedNodeService.getType(nodeRef4), TYPE_CONTENT)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef1)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef2)).thenReturn(false);
when(mockedContentClassificationService.hasClearance(nodeRef3)).thenReturn(true);
when(mockedContentClassificationService.hasClearance(nodeRef4)).thenReturn(false);
when(mockedPostMethodInvocationProcessor.getProcessor(Mockito.any())).thenReturn(processor);
NodeRef[] nodes = new NodeRef[] { nodeRef1, nodeRef2, nodeRef3, nodeRef4 };
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, nodeRef1));
assertTrue(ArrayUtils.contains(processedNodes, nodeRef3));
assertTrue(ArrayUtils.contains(processedNodes, NODE_REF_1));
assertTrue(ArrayUtils.contains(processedNodes, NODE_REF_3));
}
}

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

@@ -18,7 +18,11 @@
*/
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;
@@ -26,9 +30,12 @@ import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.ArrayList;
import java.util.Arrays;
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;
@@ -43,25 +50,25 @@ import org.mockito.Mock;
*/
public class CollectionPostMethodInvocationProcessorUnitTest
{
private static final String NON_FILTERED = "NON_FILTERED";
private static final String FILTERED = "FILTERED";
private static final String CHANGED_INPUT = "CHANGED_INPUT";
private static final String CHANGED_OUTPUT = "CHANGED_OUTPUT";
private static final String REALLY_LONG_OUTPUT_STRING = generate() + generate();
private static final String NON_FILTERED = generate();
private static final String FILTERED = generate();
@InjectMocks CollectionPostMethodInvocationProcessor collectionPostMethodInvocationProcessor;
@Mock PostMethodInvocationProcessor mockPostMethodInvocationProcessor;
@Mock BasePostMethodInvocationProcessor mockStringProcessor;
@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);
when(mockStringProcessor.process(CHANGED_INPUT)).thenReturn(CHANGED_OUTPUT);
}
@Test
@@ -83,10 +90,20 @@ public class CollectionPostMethodInvocationProcessorUnitTest
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 = Arrays.asList(NON_FILTERED);
Object collection = asList(NON_FILTERED);
Object result = collectionPostMethodInvocationProcessor.process(collection);
@@ -96,42 +113,76 @@ public class CollectionPostMethodInvocationProcessorUnitTest
@Test
public void testProcess_filteredMemberInModifiableList()
{
List<String> collection = new ArrayList<>(Arrays.asList(FILTERED));
List<String> collection = newArrayList(FILTERED);
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
assertTrue("Expected an empty list.", result.isEmpty());
}
@Test
@Test(expected = UnsupportedOperationException.class)
public void testProcess_filteredMemberInUnmodifiableList()
{
List<String> collection = Arrays.asList(FILTERED, NON_FILTERED);
List<String> collection = asList(FILTERED, NON_FILTERED);
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
assertNull("Since the collection could not be modified the whole thing should be filtered.", result);
}
@Test
public void testProcess_modifiedMember()
{
List<String> collection = Arrays.asList(NON_FILTERED, CHANGED_INPUT);
Collection<String> result = collectionPostMethodInvocationProcessor.process(collection);
assertNull("Since the Collection interface does not support replacement, the whole collection should be filtered.",
result);
collectionPostMethodInvocationProcessor.process(collection);
}
@Test
public void testProcess_noProcessorDefined()
{
List<Integer> collection = Arrays.asList(1, 4, 91);
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);
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());
}
}

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

@@ -1,112 +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.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.Arrays;
import java.util.Collection;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
/**
* Unit tests for {@link ListPostMethodInvocationProcessor}.
*
* @author Tom Page
* @since 3.0
*/
public class ListPostMethodInvocationProcessorUnitTest
{
private static final String NON_FILTERED = "NON_FILTERED";
private static final String FILTERED = "FILTERED";
private static final String CHANGED_INPUT = "CHANGED_INPUT";
private static final String CHANGED_OUTPUT = "CHANGED_OUTPUT";
@InjectMocks ListPostMethodInvocationProcessor listPostMethodInvocationProcessor;
@Mock PostMethodInvocationProcessor mockPostMethodInvocationProcessor;
@Mock BasePostMethodInvocationProcessor mockStringProcessor;
@Before
public void setUp()
{
initMocks(this);
when(mockPostMethodInvocationProcessor.getProcessor(isA(List.class))).thenReturn(listPostMethodInvocationProcessor);
when(mockPostMethodInvocationProcessor.getProcessor(isA(String.class))).thenReturn(mockStringProcessor);
when(mockStringProcessor.process(NON_FILTERED)).thenReturn(NON_FILTERED);
when(mockStringProcessor.process(FILTERED)).thenReturn(null);
when(mockStringProcessor.process(CHANGED_INPUT)).thenReturn(CHANGED_OUTPUT);
}
@Test
public void testProcessCollection_emptyList()
{
List<String> collection = new ArrayList<>();
Collection<String> result = listPostMethodInvocationProcessor.processCollection(collection, mockStringProcessor);
assertEquals(collection, result);
}
@Test
public void testProcessCollection_completelyFiltered()
{
List<String> collection = Arrays.asList(FILTERED, FILTERED);
Collection<String> result = listPostMethodInvocationProcessor.processCollection(collection, mockStringProcessor);
assertTrue("Expected all members of the list to be removed.", result.isEmpty());
}
@Test
public void testProcessCollection_supportsReplacement()
{
List<String> collection = Arrays.asList(NON_FILTERED, CHANGED_INPUT);
Collection<String> result = listPostMethodInvocationProcessor.processCollection(collection, mockStringProcessor);
List<String> expected = Arrays.asList(NON_FILTERED, CHANGED_OUTPUT);
assertEquals(expected, result);
}
@Test
public void testProcess_listOfLists()
{
List<String> innerListA = Arrays.asList(FILTERED, NON_FILTERED, CHANGED_INPUT);
List<String> innerListB = Arrays.asList(CHANGED_INPUT, FILTERED, NON_FILTERED);
List<List<String>> collection = Arrays.asList(innerListA, innerListB);
Collection<List<String>> result = listPostMethodInvocationProcessor.process(collection);
List<String> expectedInnerListA = Arrays.asList(NON_FILTERED, CHANGED_OUTPUT);
List<String> expectedInnerListB = Arrays.asList(CHANGED_OUTPUT, NON_FILTERED);
List<List<String>> expected = Arrays.asList(expectedInnerListA, expectedInnerListB);
assertEquals(expected, result);
}
}

94
rm-server/unit-test/java/org/alfresco/module/org_alfresco_module_rm/classification/interceptor/processor/SortedSetPostMethodInvocationProcessorUnitTest.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.junit.Assert.assertFalse;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
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 {@link SortedSetPostMethodInvocationProcessor}.
*
* @author Tom Page
* @since 3.0
*/
public class SortedSetPostMethodInvocationProcessorUnitTest
{
private static final String NON_FILTERED = "NON_FILTERED";
private static final String FILTERED = "FILTERED";
private static final String SHORT_INPUT = "SHORT_INPUT";
private static final String REALLY_LONG_OUTPUT_STRING = "REALLY_LONG_OUTPUT_STRING";
@InjectMocks SortedSetPostMethodInvocationProcessor sortedSetPostMethodInvocationProcessor;
@Mock BasePostMethodInvocationProcessor mockStringProcessor;
@Before
public void setUp()
{
initMocks(this);
when(mockStringProcessor.process(NON_FILTERED)).thenReturn(NON_FILTERED);
when(mockStringProcessor.process(FILTERED)).thenReturn(null);
when(mockStringProcessor.process(SHORT_INPUT)).thenReturn(REALLY_LONG_OUTPUT_STRING);
}
/**
* Given I have a sorted set of input strings
* When I pass it to the SortedSet 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 items that get changed by the filtering process to be changed
* And I expect the output set to be sorted using the same comparator as the input.
*/
@Test
public void testProcessCollection()
{
// 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(SHORT_INPUT);
collection.add(NON_FILTERED);
collection.add(FILTERED);
Collection<String> result = sortedSetPostMethodInvocationProcessor.processCollection(collection, mockStringProcessor);
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());
}
}