group parameter for search URL (#2507)

tulinkry · Vladimir Kotal · commit 70d510dbe7ad · 2018-11-13T11:06:00.000+01:00
approaches #1974
diff --git a/opengrok-indexer/src/main/java/org/opengrok/indexer/web/PageConfig.java b/opengrok-indexer/src/main/java/org/opengrok/indexer/web/PageConfig.java
@@ -24,6 +24,9 @@
  */
 package org.opengrok.indexer.web;
 
+import static org.opengrok.indexer.index.Indexer.PATH_SEPARATOR;
+import static org.opengrok.indexer.index.Indexer.PATH_SEPARATOR_STRING;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -75,9 +78,6 @@
 import org.suigeneris.jrcs.diff.Diff;
 import org.suigeneris.jrcs.diff.DifferentiationFailedException;
 
-import static org.opengrok.indexer.index.Indexer.PATH_SEPARATOR;
-import static org.opengrok.indexer.index.Indexer.PATH_SEPARATOR_STRING;
-
 /**
  * A simple container to lazy initialize common vars wrt. a single request. It
  * MUST NOT be shared between several requests and
@@ -101,8 +101,10 @@ public final class PageConfig {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(PageConfig.class);
 
-    public static final String OPEN_GROK_PROJECT = "OpenGrokProject";
-    
+    protected static final String OPEN_GROK_PROJECT = "OpenGrokProject";
+    protected static final String PROJECT_PARAM_NAME = "project";
+    protected static final String GROUP_PARAM_NAME = "group";
+
     // TODO if still used, get it from the app context
 
     private final AuthorizationFramework authFramework;
@@ -794,24 +796,33 @@ public String getRequestedProjectsAsString() {
      * <p>
      * NOTE: This method assumes, that project names do <b>not</b> contain a
      * comma (','), since this character is used as name separator!
+     * <p>
+     * It is determined as follows:
+     * <ol>
+     * <li>If there is no project in the configuration an empty set is returned. Otherwise:</li>
+     * <li>If there is only one project in the configuration,
+     * this one gets returned (no matter, what the request actually says). Otherwise</li>
+     * <li>If the request parameter {@code PROJECT_PARAM_NAME} contains any available project,
+     * the set with invalid projects removed gets returned. Otherwise:</li>
+     * <li>If the request parameter {@code GROUP_PARAM_NAME} contains any available group,
+     * then all projects from that group will be added to the result set. Otherwise:</li>
+     * <li>If the request has a cookie with the name {@code OPEN_GROK_PROJECT}
+     * and it contains any available project,
+     * the set with invalid projects removed gets returned. Otherwise:</li>
+     * <li>If a default project is set in the configuration,
+     * this project gets returned. Otherwise:</li>
+     * <li>an empty set</li>
+     * </ol>
      *
-     * @return a possible empty set of project names but never
-     * {@code null}. It is determined as follows: <ol> <li>If there is no
-     * project in the runtime environment (RTE) an empty set is returned.
-     * Otherwise:</li> <li>If there is only one project in the RTE, this one
-     * gets returned (no matter, what the request actually says). Otherwise</li>
-     * <li>If the request parameter {@code project} contains any available
-     * project, the set with invalid projects removed gets returned.
-     * Otherwise:</li> <li>If the request has a cookie with the name
-     * {@code OpenGrokProject} and it contains any available project, the set
-     * with invalid projects removed gets returned. Otherwise:</li> <li>If a
-     * default project is set in the RTE, this project gets returned.
-     * Otherwise:</li> <li>an empty set</li> </ol>
+     * @return a possible empty set of project names but never {@code null}.
+     * @see #PROJECT_PARAM_NAME
+     * @see #GROUP_PARAM_NAME
+     * @see #OPEN_GROK_PROJECT
      */
     public SortedSet<String> getRequestedProjects() {
         if (requestedProjects == null) {
             requestedProjects
-                    = getRequestedProjects("project", OPEN_GROK_PROJECT);
+                    = getRequestedProjects(PROJECT_PARAM_NAME, GROUP_PARAM_NAME, OPEN_GROK_PROJECT);
         }
         return requestedProjects;
     }
@@ -875,71 +886,90 @@ private List<String> getParamVals(String paramName) {
 
     /**
      * Same as {@link #getRequestedProjects()}, but with a variable cookieName
-     * and parameter name. This way it is trivial to implement a project filter
-     * ...
+     * and parameter name.
      *
-     * @param paramName the name of the request parameter, which possibly
-     * contains the project list in question.
-     * @param cookieName name of the cookie which possible contains project
-     * lists used as fallback
+     * @param projectParamName the name of the request parameter corresponding to a project name.
+     * @param groupParamName   the name of the request parameter corresponding to a group name
+     * @param cookieName       name of the cookie which possible contains project
+     *                         names used as fallback
      * @return set of project names. Possibly empty set but never {@code null}.
      */
-    protected SortedSet<String> getRequestedProjects(String paramName,
-            String cookieName) {
+    protected SortedSet<String> getRequestedProjects(
+            String projectParamName,
+            String groupParamName,
+            String cookieName
+    ) {
 
-        TreeSet<String> set = new TreeSet<>();
+        TreeSet<String> projectNames = new TreeSet<>();
         List<Project> projects = getEnv().getProjectList();
 
         if (projects == null) {
-            return set;
+            return projectNames;
         }
 
         /**
-         * If the project was determined from the URL, use this project.
+         * Use a project determined directly from the URL
          */
         if (getProject() != null) {
-            set.add(getProject().getName());
-            return set;
+            projectNames.add(getProject().getName());
+            return projectNames;
         }
 
+        /**
+         * Use a project if the application has only single project.
+         */
         if (projects.size() == 1) {
             Project p = projects.get(0);
             if (authFramework.isAllowed(req, p)) {
-                set.add(p.getName());
+                projectNames.add(p.getName());
             }
-            return set;
+            return projectNames;
         }
 
-        List<String> vals = getParamVals(paramName);
-        for (String s : vals) {
-            Project x = Project.getByName(s);
-            if (x != null && authFramework.isAllowed(req, x)) {
-                set.add(s);
+        /**
+         * Add all projects which match the project parameter name values
+         */
+        List<String> names = getParamVals(projectParamName);
+        for (String projectName : names) {
+            Project project = Project.getByName(projectName);
+            if (project != null && authFramework.isAllowed(req, project)) {
+                projectNames.add(projectName);
+            }
+        }
+
+        /**
+         * Add all projects which are part of a group that matches the group parameter name
+         */
+        names = getParamVals(groupParamName);
+        for (String groupName : names) {
+            Group group = Group.getByName(groupName);
+            if (group != null) {
+                projectNames.addAll(getProjectHelper().getAllGrouped(group).stream().map(Project::getName).collect(Collectors.toSet()));
             }
         }
 
-        if (set.isEmpty()) {
+        if (projectNames.isEmpty()) {
             List<String> cookies = getCookieVals(cookieName);
             for (String s : cookies) {
                 Project x = Project.getByName(s);
                 if (x != null && authFramework.isAllowed(req, x)) {
-                    set.add(s);
+                    projectNames.add(s);
                 }
             }
         }
 
-        if (set.isEmpty()) {
+        if (projectNames.isEmpty()) {
             Set<Project> defaultProjects = env.getDefaultProjects();
             if (defaultProjects != null) {
                 for (Project project : defaultProjects) {
                     if (authFramework.isAllowed(req, project)) {
-                        set.add(project.getName());
+                        projectNames.add(project.getName());
                     }
                 }
             }
         }
 
-        return set;
+        return projectNames;
     }
     
     public ProjectHelper getProjectHelper() {
diff --git a/opengrok-indexer/src/test/java/org/opengrok/indexer/web/PageConfigRequestedProjectsTest.java b/opengrok-indexer/src/test/java/org/opengrok/indexer/web/PageConfigRequestedProjectsTest.java
@@ -0,0 +1,180 @@
+package org.opengrok.indexer.web;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import javax.servlet.http.HttpServletRequest;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opengrok.indexer.authorization.AuthorizationStack;
+import org.opengrok.indexer.configuration.Group;
+import org.opengrok.indexer.configuration.Project;
+import org.opengrok.indexer.configuration.RuntimeEnvironment;
+
+public class PageConfigRequestedProjectsTest {
+
+    final RuntimeEnvironment env = RuntimeEnvironment.getInstance();
+
+    private Map<String, Project> oldProjects;
+    private Set<Group> oldGroups;
+    private AuthorizationStack oldPluginStack;
+
+    @Before
+    public void setUp() {
+        oldProjects = env.getProjects();
+        oldGroups = env.getGroups();
+        oldPluginStack = env.getPluginStack();
+
+        Set<Group> groups = new TreeSet<>();
+        Map<String, Project> projects = new TreeMap<>();
+
+        for (int i = 0; i < 10; i++) {
+            Project project = new Project();
+            project.setName("project-" + i);
+            project.setPath("/project-" + i);
+            project.setIndexed(true);
+
+            projects.put("project-" + i, project);
+        }
+
+        Group group;
+        group = new Group();
+        group.setName("group-1-2-3");
+        group.setPattern("project-(1|2|3)");
+        groups.add(group);
+
+        group = new Group();
+        group.setName("group-7-8-9");
+        group.setPattern("project-(7|8|9)");
+        groups.add(group);
+
+        env.setGroups(groups);
+        env.setProjects(projects);
+        env.setProjectsEnabled(true);
+        env.setPluginStack(null);
+
+        env.applyConfig(false, false);
+    }
+
+    @After
+    public void tearDown() {
+        env.setProjects(oldProjects);
+        env.setGroups(oldGroups);
+        env.setPluginStack(oldPluginStack);
+    }
+
+    @Test
+    public void testSingleProject() {
+        final HttpServletRequest request = createRequest(new String[]{"project-1"}, null);
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList("project-1")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testMultipleProject() {
+        final HttpServletRequest request = createRequest(new String[]{"project-1", "project-3", "project-6"}, null);
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList("project-1", "project-3", "project-6")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testSingleGroup1() {
+        final HttpServletRequest request = createRequest(null, new String[]{"group-1-2-3"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList("project-1", "project-2", "project-3")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testSingleGroup2() {
+        final HttpServletRequest request = createRequest(null, new String[]{"group-7-8-9"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList("project-7", "project-8", "project-9")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testMultipleGroup() {
+        final HttpServletRequest request = createRequest(null, new String[]{"group-1-2-3", "group-7-8-9"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList(
+                "project-1", "project-2", "project-3",
+                "project-7", "project-8", "project-9")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testMixedGroupAndProjectAddingNewProjects() {
+        final HttpServletRequest request = createRequest(new String[]{"project-1", "project-6"}, new String[]{"group-7-8-9"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList(
+                "project-1", "project-6",
+                "project-7", "project-8", "project-9")), cfg.getRequestedProjects());
+    }
+
+
+    @Test
+    public void testMixedGroupNonExistentGroupAndProjectAddingNewProjects() {
+        final HttpServletRequest request = createRequest(new String[]{"project-1", "project-6"}, new String[]{"no-group", "group-7-8-9"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList(
+                "project-1", "project-6",
+                "project-7", "project-8", "project-9")), cfg.getRequestedProjects());
+    }
+
+    @Test
+    public void testMixedGroupAndProjectInclusion() {
+        final HttpServletRequest request = createRequest(new String[]{"project-1", "project-2"}, new String[]{"group-1-2-3", "group-7-8-9"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(Arrays.asList(
+                "project-1", "project-2", "project-3",
+                "project-7", "project-8", "project-9")), cfg.getRequestedProjects());
+    }
+
+    /**
+     * Assumes that there is no defaultProjects and no cookie set up.
+     */
+    @Test
+    public void testNonExistentProject() {
+        final HttpServletRequest request = createRequest(null, new String[]{"no-project"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(), cfg.getRequestedProjects());
+    }
+
+    /**
+     * Assumes that there is no defaultProjects and no cookie set up.
+     */
+    @Test
+    public void testNonExistentGroup() {
+        final HttpServletRequest request = createRequest(null, new String[]{"no-group"});
+
+        final PageConfig cfg = PageConfig.get(request);
+        Assert.assertEquals(new HashSet<>(), cfg.getRequestedProjects());
+    }
+
+    /**
+     * Create a request with the specified path elements.
+     *
+     * @return a servlet request for the specified path
+     */
+    private static HttpServletRequest createRequest(
+            final String[] projects,
+            final String[] groups) {
+        final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+        Mockito.when(request.getParameterValues(PageConfig.PROJECT_PARAM_NAME)).thenReturn(projects);
+        Mockito.when(request.getParameterValues(PageConfig.GROUP_PARAM_NAME)).thenReturn(groups);
+        return request;
+    }
+}
