tpalfy commented on a change in pull request #4123: NIFI-7188: Adding filter
capabilities into search & prerequisite refactors
URL: https://github.com/apache/nifi/pull/4123#discussion_r393244209
##########
File path:
nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-web/nifi-web-api/src/test/java/org/apache/nifi/web/controller/ControllerSearchServiceTest.java
##########
@@ -19,537 +19,629 @@
import org.apache.nifi.authorization.Authorizer;
import org.apache.nifi.authorization.RequestAction;
import org.apache.nifi.authorization.user.NiFiUser;
+import org.apache.nifi.connectable.Connection;
+import org.apache.nifi.connectable.Funnel;
+import org.apache.nifi.connectable.Port;
import org.apache.nifi.controller.FlowController;
import org.apache.nifi.controller.ProcessorNode;
-import org.apache.nifi.controller.StandardProcessorNode;
import org.apache.nifi.controller.flow.FlowManager;
import org.apache.nifi.controller.label.Label;
import org.apache.nifi.groups.ProcessGroup;
+import org.apache.nifi.groups.RemoteProcessGroup;
import org.apache.nifi.parameter.Parameter;
import org.apache.nifi.parameter.ParameterContext;
import org.apache.nifi.parameter.ParameterContextManager;
import org.apache.nifi.parameter.ParameterDescriptor;
-import org.apache.nifi.processor.Processor;
-import org.apache.nifi.registry.VariableRegistry;
-import org.apache.nifi.registry.flow.StandardVersionControlInformation;
-import org.apache.nifi.registry.flow.VersionControlInformation;
-import org.apache.nifi.registry.variable.MutableVariableRegistry;
+import org.apache.nifi.web.api.dto.search.ComponentSearchResultDTO;
import org.apache.nifi.web.api.dto.search.SearchResultsDTO;
+import org.apache.nifi.web.search.ComponentMatcher;
+import org.apache.nifi.web.search.query.SearchQuery;
+import
org.apache.nifi.web.search.resultenrichment.ComponentSearchResultEnricher;
+import
org.apache.nifi.web.search.resultenrichment.ComponentSearchResultEnricherFactory;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.AdditionalMatchers;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-
-public class ControllerSearchServiceTest {
- private MutableVariableRegistry variableRegistry;
- private ControllerSearchService service;
- private SearchResultsDTO searchResultsDTO;
+@RunWith(MockitoJUnitRunner.class)
+public class ControllerSearchServiceTest {
+
+ public static final String PROCESS_GROUP_SECOND_LEVEL_A = "secondLevelA";
+ public static final String PROCESS_GROUP_SECOND_LEVEL_B_1 =
"secondLevelB1";
+ public static final String PROCESS_GROUP_SECOND_LEVEL_B_2 =
"secondLevelB2";
+ public static final String PROCESS_GROUP_FIRST_LEVEL_A = "firstLevelA";
+ public static final String PROCESS_GROUP_FIRST_LEVEL_B = "firstLevelB";
+ public static final String PROCESS_GROUP_ROOT = "root";
+
+ @Mock
+ private SearchQuery searchQuery;
+
+ @Mock
+ private NiFiUser user;
+
+ @Mock
+ private Authorizer authorizer;
+
+ @Mock
+ private ComponentSearchResultEnricherFactory resultEnricherFactory;
+
+ @Mock
+ private ComponentSearchResultEnricher resultEnricher;
+
+ @Mock
private FlowController flowController;
+
+ @Mock
+ private FlowManager flowManager;
+
+ @Mock
private ParameterContextManager parameterContextManager;
+ @Mock
+ private ComponentMatcher<ProcessorNode> matcherForProcessor;
+
+ @Mock
+ private ComponentMatcher<ProcessGroup> matcherForProcessGroup;
+
+ @Mock
+ private ComponentMatcher<Connection> matcherForConnection;
+
+ @Mock
+ private ComponentMatcher<RemoteProcessGroup> matcherForRemoteProcessGroup;
+
+ @Mock
+ private ComponentMatcher<Port> matcherForPort;
+
+ @Mock
+ private ComponentMatcher<Funnel> matcherForFunnel;
+
+ @Mock
+ private ComponentMatcher<ParameterContext> matcherForParameterContext;
+
+ @Mock
+ private ComponentMatcher<Parameter> matcherForParameter;
+
+ @Mock
+ private ComponentMatcher<Label> matcherForLabel;
+
+ private HashMap<String, ProcessGroup> processGroups;
+
+ private ControllerSearchService testSubject;
+
+ private SearchResultsDTO results;
+
@Before
public void setUp() {
- variableRegistry = mock(MutableVariableRegistry.class);
- service = new ControllerSearchService();
- searchResultsDTO = new SearchResultsDTO();
- flowController = mock(FlowController.class);
+
Mockito.when(resultEnricherFactory.getComponentResultEnricher(Mockito.any(ProcessGroup.class),
Mockito.any(NiFiUser.class))).thenReturn(resultEnricher);
+
Mockito.when(resultEnricherFactory.getProcessGroupResultEnricher(Mockito.any(ProcessGroup.class),
Mockito.any(NiFiUser.class))).thenReturn(resultEnricher);
+
Mockito.when(resultEnricherFactory.getParameterResultEnricher(Mockito.any(ParameterContext.class))).thenReturn(resultEnricher);
+
Mockito.when(resultEnricher.enrich(Mockito.any(ComponentSearchResultDTO.class))).thenAnswer(invocationOnMock
-> invocationOnMock.getArgument(0));
+
+
Mockito.when(matcherForProcessor.match(Mockito.any(ProcessorNode.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+
Mockito.when(matcherForProcessGroup.match(Mockito.any(ProcessGroup.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+ Mockito.when(matcherForConnection.match(Mockito.any(Connection.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+
Mockito.when(matcherForRemoteProcessGroup.match(Mockito.any(RemoteProcessGroup.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+ Mockito.when(matcherForPort.match(Mockito.any(Port.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+ Mockito.when(matcherForFunnel.match(Mockito.any(Funnel.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+
Mockito.when(matcherForParameterContext.match(Mockito.any(ParameterContext.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+ Mockito.when(matcherForParameter.match(Mockito.any(Parameter.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+ Mockito.when(matcherForLabel.match(Mockito.any(Label.class),
Mockito.any(SearchQuery.class))).thenReturn(Optional.of(new
ComponentSearchResultDTO()));
+
+ results = new SearchResultsDTO();
+ testSubject = givenTestSubject();
+ }
- FlowManager mockFlowManager = mock(FlowManager.class);
- parameterContextManager = mock(ParameterContextManager.class);
+ @Test
+ public void testSearchChecksEveryComponentType() {
+ // given
+ givenSingleProcessGroupIsSetUp();
+ givenSearchQueryIsSetUp();
+ givenNoFilters();
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenAllComponentTypeIsChecked();
+ thenAllComponentResultsAreCollected();
+ }
- doReturn(mockFlowManager).when(flowController).getFlowManager();
-
doReturn(parameterContextManager).when(mockFlowManager).getParameterContextManager();
- service.setFlowController(flowController);
+ @Test
+ public void testSearchChecksChildrenGroupsToo() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenNoFilters();
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A,
+ PROCESS_GROUP_FIRST_LEVEL_B,
+ PROCESS_GROUP_SECOND_LEVEL_B_1,
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ thenContentOfTheFollowingGroupsAreSearched(processGroups.keySet());
}
@Test
- public void testSearchInRootLevelAllAuthorizedNoVersionControl() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // first level PGs
- final ProcessGroup firstLevelAProcessGroup =
setupMockedProcessGroup("firstLevelA", rootProcessGroup, true,
variableRegistry, null);
- final ProcessGroup firstLevelBProcessGroup =
setupMockedProcessGroup("firstLevelB", rootProcessGroup, true,
variableRegistry, null);
-
- // second level PGs
- final ProcessGroup secondLevelAProcessGroup =
setupMockedProcessGroup("secondLevelA", firstLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup secondLevelBProcessGroup =
setupMockedProcessGroup("secondLevelB", firstLevelBProcessGroup, true,
variableRegistry, null);
- // third level PGs
- final ProcessGroup thirdLevelAProcessGroup =
setupMockedProcessGroup("thirdLevelA", secondLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup thirdLevelBProcessGroup =
setupMockedProcessGroup("thirdLevelB", secondLevelAProcessGroup, true,
variableRegistry, null);
-
- // link PGs together
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(firstLevelAProcessGroup);
- add(firstLevelBProcessGroup);
- }
- }).when(rootProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelAProcessGroup);
- }
- }).when(firstLevelAProcessGroup).getProcessGroups();
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelBProcessGroup);
- }
- }).when(firstLevelBProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(thirdLevelAProcessGroup);
- add(thirdLevelBProcessGroup);
- }
- }).when(secondLevelAProcessGroup).getProcessGroups();
-
- // setup processor
- setupMockedProcessor("foobar", rootProcessGroup, true,
variableRegistry);
-
- // perform search
- service.search(searchResultsDTO, "foo", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getProcessorResults().size() == 1);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getId().equals("foobarId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getId().equals("rootId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getName().equals("root"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup() ==
null);
+ public void testSearchWhenGroupIsNotAuthorized() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenNoFilters();
+ givenProcessGroupIsNotAutorized(PROCESS_GROUP_FIRST_LEVEL_B);
+
+ // when
+ testSubject.search(searchQuery, results);
+ // The authorization is not transitive, children groups might be good
candidates.
+ thenFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_B_1,
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ thenContentOfTheFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_ROOT,
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_B_1,
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
}
@Test
- public void testSearchInThirdLevelAllAuthorizedNoVersionControl() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // first level PGs
- final ProcessGroup firstLevelAProcessGroup =
setupMockedProcessGroup("firstLevelA", rootProcessGroup, true,
variableRegistry, null);
- final ProcessGroup firstLevelBProcessGroup =
setupMockedProcessGroup("firstLevelB", rootProcessGroup, true,
variableRegistry, null);
-
- // second level PGs
- final ProcessGroup secondLevelAProcessGroup =
setupMockedProcessGroup("secondLevelA", firstLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup secondLevelBProcessGroup =
setupMockedProcessGroup("secondLevelB", firstLevelBProcessGroup, true,
variableRegistry, null);
- // third level PGs
- final ProcessGroup thirdLevelAProcessGroup =
setupMockedProcessGroup("thirdLevelA", secondLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup thirdLevelBProcessGroup =
setupMockedProcessGroup("thirdLevelB", secondLevelAProcessGroup, true,
variableRegistry, null);
-
- // link PGs together
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(firstLevelAProcessGroup);
- add(firstLevelBProcessGroup);
- }
- }).when(rootProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelAProcessGroup);
- }
- }).when(firstLevelAProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelBProcessGroup);
- }
- }).when(firstLevelBProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(thirdLevelAProcessGroup);
- add(thirdLevelBProcessGroup);
- }
- }).when(secondLevelAProcessGroup).getProcessGroups();
-
- // setup processor
- setupMockedProcessor("foobar", thirdLevelAProcessGroup, true,
variableRegistry);
-
- // perform search
- service.search(searchResultsDTO, "foo", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getProcessorResults().size() == 1);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getId().equals("foobarId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getId().equals("thirdLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getName().equals("thirdLevelA"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup() ==
null);
+ public void testSearchWhenProcessNodeIsNotAuthorized() {
+ // given
+ givenSingleProcessGroupIsSetUp();
+ givenSearchQueryIsSetUp();
+ givenProcessorIsNotAuthorized();
+ givenNoFilters();
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenProcessorMatcherIsNotCalled();
}
@Test
- public void testSearchInThirdLevelParentNotAuthorizedNoVersionControl() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // first level PGs
- final ProcessGroup firstLevelAProcessGroup =
setupMockedProcessGroup("firstLevelA", rootProcessGroup, true,
variableRegistry, null);
- final ProcessGroup firstLevelBProcessGroup =
setupMockedProcessGroup("firstLevelB", rootProcessGroup, true,
variableRegistry, null);
-
- // second level PGs
- final ProcessGroup secondLevelAProcessGroup =
setupMockedProcessGroup("secondLevelA", firstLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup secondLevelBProcessGroup =
setupMockedProcessGroup("secondLevelB", firstLevelBProcessGroup, true,
variableRegistry, null);
- // third level PGs - not authorized
- final ProcessGroup thirdLevelAProcessGroup =
setupMockedProcessGroup("thirdLevelA", secondLevelAProcessGroup, false,
variableRegistry, null);
- final ProcessGroup thirdLevelBProcessGroup =
setupMockedProcessGroup("thirdLevelB", secondLevelAProcessGroup, false,
variableRegistry, null);
-
- // link PGs together
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(firstLevelAProcessGroup);
- add(firstLevelBProcessGroup);
- }
- }).when(rootProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelAProcessGroup);
- }
- }).when(firstLevelAProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelBProcessGroup);
- }
- }).when(firstLevelBProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(thirdLevelAProcessGroup);
- add(thirdLevelBProcessGroup);
- }
- }).when(secondLevelAProcessGroup).getProcessGroups();
-
- // setup processor
- setupMockedProcessor("foobar", thirdLevelAProcessGroup, true,
variableRegistry);
-
- // perform search
- service.search(searchResultsDTO, "foo", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getProcessorResults().size() == 1);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getId().equals("foobarId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getId().equals("thirdLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getName()
== null);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup() ==
null);
+ public void testSearchWithHereFilterShowsActualGroupAndSubgroupsOnly() {
+ // given
+ givenProcessGroupsAreSetUp();
+
givenSearchQueryIsSetUp(processGroups.get(PROCESS_GROUP_FIRST_LEVEL_A));
+ givenScopeFilterIsSet();
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A));
}
@Test
- public void testSearchInThirdLevelParentNotAuthorizedWithVersionControl() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // first level PGs
- final VersionControlInformation versionControlInformation = setupVC();
- final ProcessGroup firstLevelAProcessGroup =
setupMockedProcessGroup("firstLevelA", rootProcessGroup, true,
variableRegistry, versionControlInformation);
- final ProcessGroup firstLevelBProcessGroup =
setupMockedProcessGroup("firstLevelB", rootProcessGroup, true,
variableRegistry, null);
-
- // second level PGs
- final ProcessGroup secondLevelAProcessGroup =
setupMockedProcessGroup("secondLevelA", firstLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup secondLevelBProcessGroup =
setupMockedProcessGroup("secondLevelB", firstLevelBProcessGroup, true,
variableRegistry, null);
- // third level PGs - not authorized
- final ProcessGroup thirdLevelAProcessGroup =
setupMockedProcessGroup("thirdLevelA", secondLevelAProcessGroup, false,
variableRegistry, null);
- final ProcessGroup thirdLevelBProcessGroup =
setupMockedProcessGroup("thirdLevelB", secondLevelAProcessGroup, false,
variableRegistry, null);
-
- // link PGs together
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(firstLevelAProcessGroup);
- add(firstLevelBProcessGroup);
- }
- }).when(rootProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelAProcessGroup);
- }
- }).when(firstLevelAProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelBProcessGroup);
- }
- }).when(firstLevelBProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(thirdLevelAProcessGroup);
- add(thirdLevelBProcessGroup);
- }
- }).when(secondLevelAProcessGroup).getProcessGroups();
-
- // setup processor
- setupMockedProcessor("foobar", thirdLevelAProcessGroup, true,
variableRegistry);
-
- // perform search
- service.search(searchResultsDTO, "foo", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getProcessorResults().size() == 1);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getId().equals("foobarId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getId().equals("thirdLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getName()
== null);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup() !=
null);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup().getId().equals("firstLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup().getName().equals("firstLevelA"));
+ public void testSearchWithHereFilterAndInRoot() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenScopeFilterIsSet();
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A,
+ PROCESS_GROUP_FIRST_LEVEL_B,
+ PROCESS_GROUP_SECOND_LEVEL_B_1,
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ thenContentOfTheFollowingGroupsAreSearched(processGroups.keySet());
}
+
@Test
- public void
testSearchInThirdLevelParentNotAuthorizedWithVersionControlInTheGroup() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // first level PGs
- final ProcessGroup firstLevelAProcessGroup =
setupMockedProcessGroup("firstLevelA", rootProcessGroup, true,
variableRegistry, null);
- final ProcessGroup firstLevelBProcessGroup =
setupMockedProcessGroup("firstLevelB", rootProcessGroup, true,
variableRegistry, null);
-
- // second level PGs
- final ProcessGroup secondLevelAProcessGroup =
setupMockedProcessGroup("secondLevelA", firstLevelAProcessGroup, true,
variableRegistry, null);
- final ProcessGroup secondLevelBProcessGroup =
setupMockedProcessGroup("secondLevelB", firstLevelBProcessGroup, true,
variableRegistry, null);
- // third level PGs - not authorized
- final VersionControlInformation versionControlInformation = setupVC();
- final ProcessGroup thirdLevelAProcessGroup =
setupMockedProcessGroup("thirdLevelA", secondLevelAProcessGroup, false,
variableRegistry, versionControlInformation);
- final ProcessGroup thirdLevelBProcessGroup =
setupMockedProcessGroup("thirdLevelB", secondLevelAProcessGroup, false,
variableRegistry, null);
-
- // link PGs together
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(firstLevelAProcessGroup);
- add(firstLevelBProcessGroup);
- }
- }).when(rootProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelAProcessGroup);
- }
- }).when(firstLevelAProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(secondLevelBProcessGroup);
- }
- }).when(firstLevelBProcessGroup).getProcessGroups();
-
- Mockito.doReturn(new HashSet<ProcessGroup>() {
- {
- add(thirdLevelAProcessGroup);
- add(thirdLevelBProcessGroup);
- }
- }).when(secondLevelAProcessGroup).getProcessGroups();
-
- // setup processor
- setupMockedProcessor("foobar", thirdLevelAProcessGroup, true,
variableRegistry);
-
- // perform search
- service.search(searchResultsDTO, "foo", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getProcessorResults().size() == 1);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getId().equals("foobarId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getId().equals("thirdLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getParentGroup().getName()
== null);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup() !=
null);
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup().getId().equals("thirdLevelAId"));
-
assertTrue(searchResultsDTO.getProcessorResults().get(0).getVersionedGroup().getName()
== null);
+ public void testSearchWithGroupFilterShowsPointedGroupAndSubgroupsOnly() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet(PROCESS_GROUP_FIRST_LEVEL_B + "Name");
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList( //
+ PROCESS_GROUP_FIRST_LEVEL_B, //
+ PROCESS_GROUP_SECOND_LEVEL_B_1, //
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
}
@Test
- public void testSearchParameterContext() {
- final ParameterContext paramContext1 =
setupMockedParameterContext("foo", "description for parameter context foo", 1,
"foo_param", true);
- final ParameterContext paramContext2 =
setupMockedParameterContext("bar", "description for parameter context bar", 2,
"bar_param", true);
- final Set<ParameterContext> mockedParameterContexts = new
HashSet<ParameterContext>();
- mockedParameterContexts.add(paramContext1);
- mockedParameterContexts.add(paramContext2);
+ public void testSearchGroupWithLowerCase() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet((PROCESS_GROUP_FIRST_LEVEL_B +
"Name").toLowerCase());
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList( //
+ PROCESS_GROUP_FIRST_LEVEL_B, //
+ PROCESS_GROUP_SECOND_LEVEL_B_1, //
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ }
+
+ @Test
+ public void testSearchGroupWithPartialMatch() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet((PROCESS_GROUP_FIRST_LEVEL_B + "Na"));
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList( //
+ PROCESS_GROUP_FIRST_LEVEL_B, //
+ PROCESS_GROUP_SECOND_LEVEL_B_1, //
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ }
+
+ @Test
+ public void testSearchGroupBasedOnIdentifier() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet((PROCESS_GROUP_FIRST_LEVEL_B + "Id"));
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList( //
+ PROCESS_GROUP_FIRST_LEVEL_B, //
+ PROCESS_GROUP_SECOND_LEVEL_B_1, //
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ }
+
+ @Test
+ public void testSearchWithGroupWhenRoot() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet(PROCESS_GROUP_ROOT + "Name");
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList(
+ PROCESS_GROUP_FIRST_LEVEL_A,
+ PROCESS_GROUP_SECOND_LEVEL_A,
+ PROCESS_GROUP_FIRST_LEVEL_B,
+ PROCESS_GROUP_SECOND_LEVEL_B_1,
+ PROCESS_GROUP_SECOND_LEVEL_B_2));
+ thenContentOfTheFollowingGroupsAreSearched(processGroups.keySet());
+ }
-
Mockito.doReturn(mockedParameterContexts).when(parameterContextManager).getParameterContexts();
+ @Test
+ public void testSearchWithGroupWhenValueIsNonExisting() {
+ // given
+ givenProcessGroupsAreSetUp();
+ givenSearchQueryIsSetUp();
+ givenGroupFilterIsSet("Unknown");
- service.searchParameters(searchResultsDTO, "foo");
+ // when
+ testSubject.search(searchQuery, results);
- assertEquals(1, searchResultsDTO.getParameterContextResults().size());
- assertEquals("fooId",
searchResultsDTO.getParameterContextResults().get(0).getId());
- assertEquals("foo",
searchResultsDTO.getParameterContextResults().get(0).getName());
- // should have a match for the name, id, description
- assertEquals(3,
searchResultsDTO.getParameterContextResults().get(0).getMatches().size());
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList());
+ }
- assertEquals(1, searchResultsDTO.getParameterResults().size());
+ @Test
+ public void testWhenBothFiltersPresentAndScopeIsMoreRestricting() {
+ // given
+ givenProcessGroupsAreSetUp();
+
givenSearchQueryIsSetUp(processGroups.get(PROCESS_GROUP_SECOND_LEVEL_B_1));
+ givenScopeFilterIsSet();
+ givenGroupFilterIsSet(PROCESS_GROUP_FIRST_LEVEL_B + "Name");
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+
thenFollowingGroupsAreSearched(Arrays.asList(PROCESS_GROUP_SECOND_LEVEL_B_1));
+ }
- assertEquals("fooId",
searchResultsDTO.getParameterResults().get(0).getParentGroup().getId());
- assertEquals("foo_param_0",
searchResultsDTO.getParameterResults().get(0).getName());
- // and the parameter name, parameter description, and the parameter
value
- assertEquals(3,
searchResultsDTO.getParameterResults().get(0).getMatches().size());
+ @Test
+ public void testWhenBothFiltersPresentAndGroupIsMoreRestricting() {
+ // given
+ givenProcessGroupsAreSetUp();
+
givenSearchQueryIsSetUp(processGroups.get(PROCESS_GROUP_FIRST_LEVEL_B));
+ givenScopeFilterIsSet();
+ givenGroupFilterIsSet(PROCESS_GROUP_SECOND_LEVEL_B_1 + "Name");
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+
thenFollowingGroupsAreSearched(Arrays.asList(PROCESS_GROUP_SECOND_LEVEL_B_1));
}
@Test
- public void testSearchParameterContextNotAuthorized() {
- final ParameterContext paramContext1 =
setupMockedParameterContext("foo", "description for parameter context foo", 1,
"foo_param", false);
- final ParameterContext paramContext2 =
setupMockedParameterContext("bar", "description for parameter context bar", 2,
"bar_param", true);
- final Set<ParameterContext> mockedParameterContexts = new
HashSet<ParameterContext>();
- mockedParameterContexts.add(paramContext1);
- mockedParameterContexts.add(paramContext2);
+ public void testWhenBothFiltersPresentTheyAreNotOverlapping() {
+ // given
+ givenProcessGroupsAreSetUp();
+
givenSearchQueryIsSetUp(processGroups.get(PROCESS_GROUP_FIRST_LEVEL_B));
+ givenScopeFilterIsSet();
+ givenGroupFilterIsSet(PROCESS_GROUP_FIRST_LEVEL_A + "Name");
+
+ // when
+ testSubject.search(searchQuery, results);
+
+ // then
+ thenFollowingGroupsAreSearched(Arrays.asList());
+ }
-
Mockito.doReturn(mockedParameterContexts).when(parameterContextManager).getParameterContexts();
+ @Test
+ public void testSearchParameterContext() {
+ // given
+ givenSingleProcessGroupIsSetUp();
+ givenSearchQueryIsSetUp();
+ givenParameterSearchIsSetUp(true);
- service.searchParameters(searchResultsDTO, "foo");
+ // when
+ testSubject.searchParameters(searchQuery, results);
- // the matching parameter context is not readable by the user, so
there should not be any results
- assertEquals(0, searchResultsDTO.getParameterContextResults().size());
- assertEquals(0, searchResultsDTO.getParameterResults().size());
+ // then
+ thenParameterComponentTypesAreChecked();
+ thenAllParameterComponentResultsAreCollected();
}
@Test
- public void testSearchLabels() {
- // root level PG
- final ProcessGroup rootProcessGroup = setupMockedProcessGroup("root",
null, true, variableRegistry, null);
-
- // setup labels
- setupMockedLabels(rootProcessGroup);
-
- // perform search for foo
- service.search(searchResultsDTO, "FOO", rootProcessGroup);
-
- assertTrue(searchResultsDTO.getLabelResults().size() == 1);
-
assertTrue(searchResultsDTO.getLabelResults().get(0).getId().equals("foo"));
-
assertTrue(searchResultsDTO.getLabelResults().get(0).getName().equals("Value
for label foo"));
- }
-
- /**
- * Mocks Labels including isAuthorized() and their identifier and value
- *
- * @param containingProcessGroup The process group
- */
- private static void setupMockedLabels(final ProcessGroup
containingProcessGroup) {
- final Label label1 = mock(Label.class);
-
Mockito.doReturn(true).when(label1).isAuthorized(AdditionalMatchers.or(any(Authorizer.class),
isNull()), eq(RequestAction.READ),
- AdditionalMatchers.or(any(NiFiUser.class), isNull()));
- Mockito.doReturn("foo").when(label1).getIdentifier();
- Mockito.doReturn("Value for label foo").when(label1).getValue();
-
- final Label label2 = mock(Label.class);
-
Mockito.doReturn(false).when(label2).isAuthorized(AdditionalMatchers.or(any(Authorizer.class),
isNull()), eq(RequestAction.READ),
- AdditionalMatchers.or(any(NiFiUser.class), isNull()));
- Mockito.doReturn("bar").when(label2).getIdentifier();
- Mockito.doReturn("Value for label bar, but FOO is in here
too").when(label2).getValue();
-
- // assign labels to the PG
- Mockito.doReturn(new HashSet<Label>() {
- {
- add(label1);
- add(label2);
- }
- }).when(containingProcessGroup).getLabels();
- }
-
- /**
- * Sets up a mock Parameter Context including isAuthorized()
- * @param name name of the parameter context
- * @param description description of the parameter context
- * @param numberOfParams number of parameters to include as part
of this context
- * @param parameterNamePrefix a prefix for the parameter names
- * @param authorizedToRead whether or not the user can read the
parameter context
- * @return ParameterContext
- */
- private ParameterContext setupMockedParameterContext(String name, String
description, int numberOfParams, String parameterNamePrefix, boolean
authorizedToRead) {
- final ParameterContext parameterContext = mock(ParameterContext.class);
- Mockito.doReturn(name + "Id").when(parameterContext).getIdentifier();
- Mockito.doReturn(name).when(parameterContext).getName();
- Mockito.doReturn(description).when(parameterContext).getDescription();
-
-
Mockito.doReturn(authorizedToRead).when(parameterContext).isAuthorized(AdditionalMatchers.or(any(Authorizer.class),
isNull()), eq(RequestAction.READ),
- AdditionalMatchers.or(any(NiFiUser.class), isNull()));
-
- Map<ParameterDescriptor, Parameter> parameters = new HashMap<>();
- for (int i = 0; i < numberOfParams; i++) {
- final ParameterDescriptor descriptor = new
ParameterDescriptor.Builder()
- .name(parameterNamePrefix + "_" + i)
- .description("Description for " + parameterNamePrefix +
"_" + i)
- .sensitive(false)
- .build();
-
- final Parameter param = new Parameter(descriptor,
parameterNamePrefix + "_" + i + " value");
- parameters.put(descriptor, param);
+ public void testSearchParameterContextWhenNotAuthorized() {
+ // given
+ givenSingleProcessGroupIsSetUp();
+ givenSearchQueryIsSetUp();
+ givenParameterSearchIsSetUp(false);
+
+ // when
+ testSubject.searchParameters(searchQuery, results);
+
+ // then
+ thenParameterSpecificComponentTypesAreNotChecked();
+ }
+
+ private ControllerSearchService givenTestSubject() {
+ final ControllerSearchService result = new ControllerSearchService();
+ result.setAuthorizer(authorizer);
+ result.setFlowController(flowController);
+ result.setMatcherForProcessor(matcherForProcessor);
+ result.setMatcherForProcessGroup(matcherForProcessGroup);
+ result.setMatcherForConnection(matcherForConnection);
+ result.setMatcherForRemoteProcessGroup(matcherForRemoteProcessGroup);
+ result.setMatcherForPort(matcherForPort);
+ result.setMatcherForFunnel(matcherForFunnel);
+ result.setMatcherForParameterContext(matcherForParameterContext);
+ result.setMatcherForParameter(matcherForParameter);
+ result.setMatcherForLabel(matcherForLabel);
+ result.setResultEnricherFactory(resultEnricherFactory);
+ return result;
+ }
+
+ private void givenSingleProcessGroupIsSetUp() {
+ final ProcessGroup root = givenProcessGroup(PROCESS_GROUP_ROOT, true,
Collections.emptySet(), Collections.emptySet());
+ processGroups = new HashMap<>();
+ processGroups.put(PROCESS_GROUP_ROOT, root);
+
+ final ProcessorNode processorNode = Mockito.mock(ProcessorNode.class);
+ Mockito.when(processorNode.isAuthorized(authorizer,
RequestAction.READ, user)).thenReturn(true);
+
Mockito.when(root.getProcessors()).thenReturn(Collections.singletonList(processorNode));
+
+ final Connection connection = Mockito.mock(Connection.class);
+ Mockito.when(connection.isAuthorized(authorizer, RequestAction.READ,
user)).thenReturn(true);
+ Mockito.when(root.getConnections()).thenReturn(new
HashSet<>(Arrays.asList(connection)));
+
+ final RemoteProcessGroup remoteProcessGroup =
Mockito.mock(RemoteProcessGroup.class);
+ Mockito.when(remoteProcessGroup.isAuthorized(authorizer,
RequestAction.READ, user)).thenReturn(true);
+ Mockito.when(root.getRemoteProcessGroups()).thenReturn(new
HashSet<>(Arrays.asList(remoteProcessGroup)));
+
+ final Port port = Mockito.mock(Port.class);
+ Mockito.when(port.isAuthorized(authorizer, RequestAction.READ,
user)).thenReturn(true);
+ Mockito.when(root.getInputPorts()).thenReturn(new
HashSet<>(Arrays.asList(port)));
+ Mockito.when(root.getOutputPorts()).thenReturn(new
HashSet<>(Arrays.asList(port)));
+
+ final Funnel funnel = Mockito.mock(Funnel.class);
+ Mockito.when(funnel.isAuthorized(authorizer, RequestAction.READ,
user)).thenReturn(true);
+ Mockito.when(root.getFunnels()).thenReturn(new
HashSet<>(Arrays.asList(funnel)));
+
+ final Label label = Mockito.mock(Label.class);
+ Mockito.when(label.isAuthorized(authorizer, RequestAction.READ,
user)).thenReturn(true);
+ Mockito.when(root.getLabels()).thenReturn(new
HashSet<>(Arrays.asList(label)));
+ }
+
+ private void givenProcessGroupsAreSetUp() {
+ final ProcessGroup secondLevelAProcessGroup =
givenProcessGroup(PROCESS_GROUP_SECOND_LEVEL_A, true, Collections.emptySet(),
Collections.emptySet());
+ final ProcessGroup secondLevelB1ProcessGroup =
givenProcessGroup(PROCESS_GROUP_SECOND_LEVEL_B_1, true, Collections.emptySet(),
Collections.emptySet());
+ final ProcessGroup secondLevelB2ProcessGroup =
givenProcessGroup(PROCESS_GROUP_SECOND_LEVEL_B_2, true, Collections.emptySet(),
Collections.emptySet());
+
+ final ProcessGroup firstLevelAProcessGroup =
givenProcessGroup(PROCESS_GROUP_FIRST_LEVEL_A, //
+ true, Collections.emptySet(),
Collections.singleton(secondLevelAProcessGroup));
+ final ProcessGroup firstLevelBProcessGroup =
givenProcessGroup(PROCESS_GROUP_FIRST_LEVEL_B, //
+ true, Collections.emptySet(), new
HashSet<>(Arrays.asList(secondLevelB1ProcessGroup, secondLevelB2ProcessGroup)));
+
+ final ProcessGroup root = givenProcessGroup(PROCESS_GROUP_ROOT, //
+ true, Collections.emptySet(), new
HashSet<>(Arrays.asList(firstLevelAProcessGroup, firstLevelBProcessGroup)));
+
+ Mockito.when(firstLevelAProcessGroup.getParent()).thenReturn(root);
Review comment:
We could remove these and add
```java
children.forEach(child ->
Mockito.when(child.getParent()).thenReturn(result));
```
in `givenProcessGroup` instead.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
