ACS-6125: test support for path queries against categories

tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodeWithCategoryIndexingTests.java

@@ -0,0 +1,146 @@
+package org.alfresco.elasticsearch.reindexing;
+
+import static java.lang.String.format;
+
+import static org.alfresco.elasticsearch.SearchQueryService.req;
+import static org.alfresco.utility.report.log.Step.STEP;
+
+import org.alfresco.elasticsearch.reindexing.utils.Categories;
+import org.alfresco.rest.search.SearchRequest;
+import org.alfresco.utility.model.TestGroup;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * Tests verifying live indexing of secondary children and ANCESTOR index in Elasticsearch.
+ */
+@SuppressWarnings({"PMD.JUnitTestsShouldIncludeAssert", "PMD.JUnit4TestShouldUseTestAnnotation"}) // these are testng tests and use searchQueryService.expectResultsFromQuery for assertion
+public class NodeWithCategoryIndexingTests extends NodesSecondaryChildrenRelatedTests
+{
+
+    @Autowired
+    private Categories categories;
+
+    /*
+    A --- B  (folders)
+    \____
+         \
+    K --- L  (categories)
+     */
+    @BeforeClass(alwaysRun = true)
+    @Override
+    public void dataPreparation()
+    {
+        super.dataPreparation();
+
+        // given
+        STEP("Create nested folders in site's Document Library.");
+        folders().createNestedFolders(A, B);
+
+        STEP("Create nested categories.");
+        categories.createNestedCategories(K, L);
+
+        STEP("Link folders to category.");
+        folders(A).linkToCategory(categories.get(L));
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void testParentQueryAgainstCategory()
+    {
+        // then
+        STEP("Verify that searching by PARENT and category will find one descendant node: categoryL.");
+        SearchRequest query = req("PARENT:" + categories.get(K).getId());
+        searchQueryService.expectResultsFromQuery(query, testUser, categories.get(L).getName());
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void testParentQueryAgainstFolder()
+    {
+        // then
+        STEP("Verify that searching by PARENT and category will find one descendant node: folderA.");
+        SearchRequest query = req("PARENT:" + categories.get(L).getId());
+        searchQueryService.expectResultsFromQuery(query, testUser, folders(A).getName());
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void testParentQueryAgainstFolderAfterCategoryDeletion()
+    {
+        // given
+        STEP("Create nested folders in site's Document Library.");
+        folders().createNestedFolders(C);
+
+        STEP("Create nested categories.");
+        categories.createNestedCategories(M);
+
+        STEP("Link folders to category.");
+        folders(C).linkToCategory(categories.get(M));
+
+        // when
+        STEP("Verify that searching by PARENT and category will find one descendant node: folderC.");
+        SearchRequest query = req("PARENT:" + categories.get(M).getId());
+        searchQueryService.expectResultsFromQuery(query, testUser, folders(C).getName());
+
+        // then
+        STEP("Delete categoryM.");
+        categories.delete(M);
+
+        STEP("Verify that searching by PARENT and deleted category will find no descendant nodes.");
+        searchQueryService.expectResultsFromQuery(query, testUser);
+    }
+
+
+    @Test(groups = TestGroup.SEARCH)
+    public void testSearchByPath()
+    {
+        // given
+        String Kname = categories.get(K).getName();
+        String Lname = categories.get(L).getName();
+        String Aname = folders(A).getName();
+
+        // then
+        STEP("Verify that searching by PATH and category will find: folderA");
+        SearchRequest query = req(format("PATH:'/cm:categoryRoot/cm:generalclassifiable/cm:%s/cm:%s/cm:%s'", Kname, Lname, Aname));
+        searchQueryService.expectResultsFromQuery(query, testUser, folders(A).getName());
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void ensureCategoriesAreNotTransitive_lookingForExactChildren()
+    {
+        // given
+        String Kname = categories.get(K).getName();
+        String Lname = categories.get(L).getName();
+        String Aname = folders(A).getName();
+        String Bname = folders(B).getName();
+
+        // then
+        STEP("Verify that searching by PATH for nested folder will return no results (Dependency to category is not transitive)");
+        SearchRequest query = req(format("PATH:'/cm:categoryRoot/cm:generalclassifiable/cm:%s/cm:%s/cm:%s/cm:%s'", Kname, Lname, Aname, Bname));
+        searchQueryService.expectResultsFromQuery(query, testUser);
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void ensureCategoriesAreNotTransitive_lookingForAllChildren()
+    {
+        // given
+        String Kname = categories.get(K).getName();
+        String Lname = categories.get(L).getName();
+
+        // then
+        STEP("Verify that searching by PATH and category will find: folderA");
+        SearchRequest query = req(format("PATH:'/cm:categoryRoot/cm:generalclassifiable/cm:%s/cm:%s//*'", Kname, Lname));
+        searchQueryService.expectResultsFromQuery(query, testUser, folders(A).getName());
+    }
+
+    @Test(groups = TestGroup.SEARCH)
+    public void ensureCategoriesAreNotTransitive_lookingForAllChildren_byParentCategory()
+    {
+        // given
+        String Kname = categories.get(K).getName();
+
+        // then
+        STEP("Verify that searching by PATH and category will find: folderA");
+        SearchRequest query = req(format("PATH:'/cm:categoryRoot/cm:generalclassifiable/cm:%s//*'", Kname));
+        searchQueryService.expectResultsFromQuery(query, testUser, categories.get(L).getName(), folders(A).getName());
+    }
+}

tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryChildrenRelatedTests.java

@@ -12,6 +12,8 @@
 
 import org.alfresco.elasticsearch.SearchQueryService;
 import org.alfresco.rest.core.RestWrapper;
+import org.alfresco.rest.model.RestCategoryLinkBodyModel;
+import org.alfresco.rest.model.RestCategoryModel;
 import org.alfresco.rest.model.RestNodeBodyMoveCopyModel;
 import org.alfresco.rest.model.RestNodeModel;
 import org.alfresco.tas.AlfrescoStackInitializer;
@@ -193,6 +195,12 @@ protected Folder copyTo(Folder target)
             return folderCopy;
         }
 
+        protected void linkToCategory(RestCategoryModel category) {
+            restClient.authenticateUser(testUser).withCoreAPI()
+                    .usingNode(this)
+                    .linkToCategory(RestCategoryLinkBodyModel.builder().categoryId(category.getId()).create());
+        }
+
         private void delete()
         {
             dataContent.usingUser(user).usingResource(this).deleteContent();
@@ -211,6 +219,8 @@ protected FileModel createDocument(String filename)
                 .createContent(new FileModel(filename, FileType.TEXT_PLAIN, "content"));
         }
 
+
+
         private static String generateRandomFolderNameWith(String folderSuffix)
         {
             return "folder" + folderSuffix + "_" + UUID.randomUUID();

tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/utils/Categories.java

@@ -0,0 +1,63 @@
+package org.alfresco.elasticsearch.reindexing.utils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.alfresco.rest.core.RestWrapper;
+import org.alfresco.rest.model.RestCategoryModel;
+import org.alfresco.utility.data.DataUser;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Categories
+{
+    private static final String ROOT_CATEGORY_ID = "-root-";
+    public static final RestCategoryModel ROOT_CATEGORY = RestCategoryModel.builder()
+            .id(ROOT_CATEGORY_ID)
+            .create();
+
+    @Autowired
+    private RestWrapper restClient;
+
+    @Autowired
+    private DataUser dataUser;
+
+    private final Map<String, Category> categories = new HashMap<>();
+
+    public List<Category> createNestedCategories(String... nestedCategoriesNames)
+    {
+        if (nestedCategoriesNames.length == 0)
+        {
+            return Collections.emptyList();
+        }
+
+        List<Category> categories = new ArrayList<>();
+        categories.add(new Category(restClient, dataUser.getAdminUser(), ROOT_CATEGORY, nestedCategoriesNames[0]));
+
+        for (int i = 1; i < nestedCategoriesNames.length; i++)
+        {
+            categories.add(categories.get(i - 1).createSubcategory(nestedCategoriesNames[i]));
+        }
+
+        categories.forEach(category -> this.categories.put(category.getName(), category));
+
+        return categories;
+    }
+
+    public Category get(String categoryName) {
+        return categories.get(categoryName);
+    }
+
+    public void delete(String categoryName) {
+        Category categoryToDelete = categories.remove(categoryName);
+
+        restClient.authenticateUser(dataUser.getAdminUser())
+                .withCoreAPI()
+                .usingCategory(categoryToDelete)
+                .deleteCategory();
+    }
+}

tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/utils/Category.java

@@ -0,0 +1,35 @@
+package org.alfresco.elasticsearch.reindexing.utils;
+
+import org.alfresco.rest.core.RestWrapper;
+import org.alfresco.rest.model.RestCategoryModel;
+import org.alfresco.utility.model.UserModel;
+
+public class Category extends RestCategoryModel
+{
+    private final RestWrapper restClient;
+
+    private final UserModel user;
+
+    public Category(RestWrapper restClient, UserModel user, RestCategoryModel parent, String newCategoryName)
+    {
+        this.restClient = restClient;
+        this.user = user;
+
+        RestCategoryModel category = restClient.authenticateUser(user)
+                .withCoreAPI()
+                .usingCategory(parent)
+                .createSingleCategory(RestCategoryModel.builder().name(newCategoryName).create());
+
+        setName(category.getName());
+        setCount(category.getCount());
+        setId(category.getId());
+        setPath(category.getPath());
+        setParentId(category.getParentId());
+        setHasChildren(category.getHasChildren());
+    }
+
+    public Category createSubcategory(String subcategoryName)
+    {
+        return new Category(restClient, user, this, subcategoryName);
+    }
+}

tests/testcontainers-env/src/main/java/org/alfresco/tas/AlfrescoStackInitializer.java

@@ -404,6 +404,7 @@ protected GenericContainer createAlfrescoContainer()
                                 "-Dcsrf.filter.enabled=false " +
                                 "-Dalfresco.restApi.basicAuthScheme=true " +
                                 "-Dquery.cmis.queryConsistency=EVENTUAL " +
+                                "-Dquery.fts.queryConsistency=EVENTUAL " +
                                 "-Xms1500m -Xmx1500m ")
                        .withNetwork(network)
                        .withNetworkAliases("alfresco")