createNestedFolders(String... folderSuffixes);
+
+ void delete(Folder folder);
+ }
+}
diff --git a/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryParentIndexingTests.java b/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryParentIndexingTests.java
new file mode 100644
index 0000000000..7fb478a29f
--- /dev/null
+++ b/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryParentIndexingTests.java
@@ -0,0 +1,330 @@
+package org.alfresco.elasticsearch.reindexing;
+
+import static org.alfresco.elasticsearch.SearchQueryService.req;
+import static org.alfresco.utility.report.log.Step.STEP;
+
+import org.alfresco.rest.search.SearchRequest;
+import org.alfresco.utility.model.FileModel;
+import org.alfresco.utility.model.TestGroup;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * Tests verifying live indexing of secondary children and PARENT index in Elasticsearch.
+ */
+@SuppressWarnings({"PMD.JUnitTestsShouldIncludeAssert"}) // these are TAS E2E tests and use searchQueryService.expectResultsFromQuery for assertion
+public class NodesSecondaryParentIndexingTests extends NodesSecondaryChildrenRelatedTests
+{
+
+ private FileModel fileInP;
+
+ /**
+ * Creates a user and a private site containing below hierarchy of folders.
+ *
+ * Site
+ * DL (Document Library)
+ * += fA += fB += fC (folderC)
+ * / / |
+ * + + +
+ * += fK += fL += fM
+ * | +
+ * + |
+ * += fX += fY += fZ
+ * += fP += file -+ fA
+ * += fQ
+ * += fR
+ * += fS
+ *
+ * Parent += Child - primary parent-child relationship
+ * Parent +- Child - secondary parent-child relationship
+ */
+ @BeforeClass(alwaysRun = true)
+ @Override
+ public void dataPreparation()
+ {
+ super.dataPreparation();
+
+ // given
+ STEP("Create few sets of nested folders in site's Document Library.");
+ folders().createNestedFolders(A, B, C);
+ folders().createNestedFolders(K, L, M);
+ folders().createNestedFolders(X, Y, Z);
+ folders().createFolder(P);
+ folders().createFolder(Q);
+ folders().createFolder(R);
+ folders().createFolder(S);
+ fileInP = folders(P).createRandomDocument();
+
+ STEP("Create few secondary parent-child relationships.");
+ folders(K).addSecondaryChild(folders(B));
+ folders(X).addSecondaryChild(folders(K));
+ folders(L).addSecondaryChildren(folders(C), folders(Y));
+ folders(M).addSecondaryChild(folders(C));
+ folders(A).addSecondaryChild(fileInP);
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithNodeHavingOneSecondaryChild()
+ {
+ // then
+ STEP("Verify that searching rby PARENT and folderM will find node folderC.");
+ SearchRequest query = req("PARENT:" + folders(M).getNodeRef());
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ folders(C).getName());
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithNodeHavingTwoSecondaryChildren()
+ {
+ // then
+ STEP("Verify that searching by PARENT and folderL will find nodes: folderM, FolderC and folderY.");
+ SearchRequest query = req("PARENT:" + folders(L).getNodeRef());
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // primary child
+ folders(M).getName(),
+ // secondary children
+ folders(C).getName(),
+ folders(Y).getName());
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithDocumentAsSecondaryChild()
+ {
+ // then
+ STEP("Verify that searching by PARENT and folderA will find nodes: folderB and file.");
+ SearchRequest query = req("PARENT:" + folders(A).getNodeRef());
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // primary child
+ folders(B).getName(),
+ // secondary child
+ fileInP.getName());
+ }
+
+ /**
+ * Verify that removing secondary parent-child relationship will result in updating ES index: PARENT.
+ * Test changes below folders hierarchy:
+ *
+ * DL
+ * += fQ
+ * +
+ * |
+ * += fR
+ *
+ * into:
+ *
+ * DL
+ * += fQ
+ * += fR
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithDeletedSecondaryRelationship()
+ {
+ // given
+ STEP("Add to folderQ a secondary child folderR and verify if it can be found using PARENT index and secondary parent node reference.");
+ folders(Q).addSecondaryChild(folders(R));
+
+ SearchRequest query = req("PARENT:" + folders(Q).getNodeRef());
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // secondary child
+ folders(R).getName());
+
+ // when
+ STEP("Delete the secondary parent relationship between folderQ and FolderR and verify that folderR cannot be found by PARENT and folderQ anymore.");
+ folders(Q).removeSecondaryChild(folders(R));
+
+ // then
+ searchQueryService.expectNoResultsFromQuery(query, testUser);
+ }
+
+ /**
+ * Verify that removing a node D (fD) having a secondary children relationship will remove the relationships and update PARENT index in ES.
+ * Test changes below folders hierarchy from:
+ *
+ * DL
+ * += fQ
+ * +
+ * |
+ * += fE += fF
+ * +
+ * |
+ * += fR
+ *
+ * into:
+ *
+ * DL
+ * += fQ
+ * += fR
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithDeletedSecondaryParentNode()
+ {
+ // given
+ STEP("Create two nested folders (E and F) in Document Library.");
+ Folder folderE = folders().createFolder( "E");
+ Folder folderF = folderE.createNestedFolder( "F");
+ STEP("Make folderE a secondary children of folderQ and folderR a secondary children of folderE.");
+ folders(Q).addSecondaryChild(folderE);
+ folderE.addSecondaryChild(folders(R));
+
+ STEP("Verify that searching by PARENT and folderQ will find its secondary child: folderE.");
+ SearchRequest queryParentQ = req("PARENT:" + folders(Q).getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentQ, testUser,
+ // secondary child
+ folderE.getName());
+ STEP("Verify that searching by PARENT and folderE will find its primary and secondary children: folderF and folderR.");
+ SearchRequest queryParentD = req("PARENT:" + folderE.getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentD, testUser,
+ // primary child
+ folderF.getName(),
+ // secondary child
+ folders(R).getName());
+
+ // when
+ STEP("Delete folderE and verify that PARENT was updated for nodes folderQ and folderR.");
+ folders().delete(folderE);
+
+ // then
+ searchQueryService.expectNoResultsFromQuery(queryParentQ, testUser);
+ searchQueryService.expectNoResultsFromQuery(queryParentD, testUser);
+ }
+
+ /**
+ * Verify that moving folder D (fD) containing secondary children from hierarchy:
+ *
+ * DL
+ * += fQ += fD +- fP += file
+ * += fR
+ *
+ * to:
+ *
+ * DL
+ * += fQ
+ * += fR += fD +- fP += file
+ *
+ * will update PARENT index in ES.
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithMovedSecondaryParentNode()
+ {
+ // given
+ STEP("Create folderD inside folderQ, and add folderP to D as a secondary child.");
+ Folder folderD = folders(Q).createNestedFolder( "D");
+ folderD.addSecondaryChild(folders(P));
+
+ STEP("Verify that searching by PARENT and folderD will find node folderP.");
+ SearchRequest queryParentD = req("PARENT:" + folderD.getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentD, testUser,
+ // secondary child
+ folders(P).getName());
+ STEP("Verify that searching by PARENT and folderQ will find node folderD.");
+ SearchRequest queryParentQ = req("PARENT:" + folders(Q).getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentQ, testUser,
+ // primary child
+ folderD.getName());
+
+ // when
+ STEP("Move folderD from folderQ to folderR.");
+ folderD.moveTo(folders(R));
+
+ // then
+ STEP("Verify that search result for PARENT and folderD didn't change.");
+ searchQueryService.expectResultsFromQuery(queryParentD, testUser,
+ // secondary child
+ folders(P).getName());
+ STEP("Verify that searching by PARENT and folderQ doesn't return any node anymore.");
+ searchQueryService.expectNoResultsFromQuery(queryParentQ, testUser);
+ STEP("Verify that searching by PARENT and folderR will find node folderD.");
+ SearchRequest queryParentR = req("PARENT:" + folders(R).getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentR, testUser,
+ // primary child
+ folderD.getName());
+
+ STEP("Clean-up - delete folderD.");
+ folders().delete(folderD);
+ }
+
+ /**
+ * Verify that copying folder will also result in copying folder's secondary children and update PARENT index in ES.
+ * Test changes below folders hierarchy:
+ *
+ * DL
+ * += fS += fG += fH
+ * +
+ * /
+ * += fP += file
+ * += fT
+ *
+ * into:
+ *
+ * DL
+ * += fS += fG += fH
+ * +
+ * /
+ * += fP += file
+ * \
+ * +
+ * += fT += fG-c += fH-c
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithCopiedSecondaryParentNode()
+ {
+ // given
+ STEP("Create nested folders (G and H) inside folderS and folderT in Document Library. Make folderP a secondary child of folderG.");
+ Folder folderG = folders(S).createNestedFolder( "G");
+ Folder folderH = folderG.createNestedFolder("H");
+ Folder folderT = folders().createFolder("T");
+ folderG.addSecondaryChild(folders(P));
+
+ STEP("Verify that searching by PARENT and folderG will find nodes: folderH, folderP and file.");
+ SearchRequest queryParentG = req("PARENT:" + folderG.getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentG, testUser,
+ // primary child
+ folderH.getName(),
+ // secondary child
+ folders(P).getName());
+ STEP("Verify that searching by PARENT and folderS will find nodes: folderG, folderH, folderP and file.");
+ SearchRequest queryParentS = req("PARENT:" + folders(S).getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentS, testUser,
+ // primary child
+ folderG.getName());
+ STEP("Verify that searching by PARENT and folderP will find node: file.");
+ SearchRequest queryParentP = req("PARENT:" + folders(P).getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentP, testUser,
+ // primary child
+ fileInP.getName());
+
+ // when
+ STEP("Copy folderG with its content to folderT.");
+ Folder folderGCopy = folderG.copyTo(folderT);
+
+ // then
+ STEP("Verify that search result for PARENT and folderS didn't change.");
+ searchQueryService.expectResultsFromQuery(queryParentS, testUser,
+ // primary child
+ folderG.getName());
+ STEP("Verify that searching by PARENT and folderS/folderG will find nodes: folderH, folderP and file in P.");
+ searchQueryService.expectResultsFromQuery(queryParentG, testUser,
+ // primary child
+ folderH.getName(),
+ // secondary child
+ folders(P).getName());
+ STEP("Verify that folderG was copied with secondary parent-child relationship and PARENT reflects that - search by folderT/folderGCopy should find nodes: folderH, folderP and file in P.");
+ SearchRequest queryParentGCopy = req("PARENT:" + folderGCopy.getNodeRef());
+ searchQueryService.expectResultsFromQuery(queryParentGCopy, testUser,
+ // primary child
+ folderH.getName(), // name is the same as folderH-copy
+ // secondary child
+ folders(P).getName());
+ STEP("Verify that this time searching by PARENT and folderP will find node: file.");
+ searchQueryService.expectResultsFromQuery(queryParentP, testUser,
+ // primary child
+ fileInP.getName());
+
+ STEP("Clean-up - delete folderG and folderT (with G's copy).");
+ folders().delete(folderG);
+ folders().delete(folderT);
+ }
+}
diff --git a/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryPathIndexingTests.java b/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryPathIndexingTests.java
new file mode 100644
index 0000000000..5c7e2a9129
--- /dev/null
+++ b/tests/tas-elasticsearch/src/test/java/org/alfresco/elasticsearch/reindexing/NodesSecondaryPathIndexingTests.java
@@ -0,0 +1,363 @@
+package org.alfresco.elasticsearch.reindexing;
+
+import static org.alfresco.elasticsearch.SearchQueryService.req;
+import static org.alfresco.utility.report.log.Step.STEP;
+
+import org.alfresco.rest.search.SearchRequest;
+import org.alfresco.utility.model.FileModel;
+import org.alfresco.utility.model.TestGroup;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+/**
+ * Tests verifying live indexing of secondary children and PATH index in Elasticsearch.
+ */
+@SuppressWarnings({"PMD.JUnitTestsShouldIncludeAssert"}) // these are TAS E2E tests and use searchQueryService.expectResultsFromQuery for assertion
+public class NodesSecondaryPathIndexingTests extends NodesSecondaryChildrenRelatedTests
+{
+
+ private FileModel fileInP;
+
+ /**
+ * Creates a user and a private site containing below hierarchy of folders.
+ *
+ * Site
+ * DL (Document Library)
+ * += fA += fB += fC (folderC)
+ * / / |
+ * + + +
+ * += fK += fL += fM
+ * | +
+ * + |
+ * += fX += fY += fZ
+ * += fP += file -+ fA
+ * += fQ
+ * += fR
+ * += fS
+ *
+ * Parent += Child - primary parent-child relationship
+ * Parent +- Child - secondary parent-child relationship
+ */
+ @BeforeClass(alwaysRun = true)
+ @Override
+ public void dataPreparation()
+ {
+ super.dataPreparation();
+
+ // given
+ STEP("Create few sets of nested folders in site's Document Library.");
+ folders().createNestedFolders(A, B, C);
+ folders().createNestedFolders(K, L, M);
+ folders().createNestedFolders(X, Y, Z);
+ folders().createFolder(P);
+ folders().createFolder(Q);
+ folders().createFolder(R);
+ folders().createFolder(S);
+ fileInP = folders(P).createRandomDocument();
+
+ STEP("Create few secondary parent-child relationships.");
+ folders(K).addSecondaryChild(folders(B));
+ folders(X).addSecondaryChild(folders(K));
+ folders(L).addSecondaryChildren(folders(C), folders(Y));
+ folders(M).addSecondaryChild(folders(C));
+ folders(A).addSecondaryChild(fileInP);
+
+ STEP("Add to folderQ a secondary child folderR.");
+ folders(Q).addSecondaryChild(folders(R));
+
+ // when
+ STEP("Delete the secondary parent relationship between folderQ and FolderR.");
+ folders(Q).removeSecondaryChild(folders(R));
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithNodeHavingOneSecondaryChild()
+ {
+ // then
+ STEP("Verify that folderC can be found by secondary PATH using secondary parent folderM.");
+ SearchRequest query = req("PATH:\"//cm:" + folders(M).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // secondary path
+ folders(C).getName());
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithNodeHavingOnePrimaryAndTwoSecondaryChildren()
+ {
+ // then
+ STEP("Verify that primary and secondary children of folderL can be found using PATH index.");
+ SearchRequest query = req("PATH:\"//cm:" + folders(L).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // primary path
+ folders(M).getName(),
+ // secondary path
+ folders(C).getName(),
+ folders(Y).getName(),
+ folders(Z).getName()
+ );
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithNodeHavingDocumentAsSecondaryChild()
+ {
+ // then
+ STEP("Verify that a file being a secondary child of folderA can be found using PATH index.");
+ SearchRequest query = req("PATH:\"//cm:" + folders(A).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // primary path
+ folders(B).getName(),
+ folders(C).getName(),
+ // secondary path
+ fileInP.getName());
+ }
+
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithNodeHavingComplexSecondaryRelationship()
+ {
+ // then
+ STEP("Verify that all secondary children of folderX can be found.");
+ SearchRequest query = req("PATH:\"//cm:" + folders(X).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(query, testUser,
+ // primary path
+ folders(Y).getName(),
+ folders(Z).getName(),
+ // secondary path
+ folders(B).getName(),
+ folders(C).getName(),
+ folders(K).getName(),
+ folders(L).getName(),
+ folders(M).getName()
+ );
+ }
+
+ /**
+ * Verify that removing secondary parent-child relationship will result in updating ES index: PATH.
+ * Test changes below folders hierarchy:
+ *
+ * DL
+ * += fQ
+ * +
+ * |
+ * += fR
+ *
+ * into:
+ *
+ * DL
+ * += fQ
+ * += fR
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithDeletedSecondaryRelationship()
+ {
+ // then
+ STEP("Verify that folderR cannot be found by PATH and folderQ anymore.");
+ SearchRequest query = req("PATH:\"//cm:" + folders(Q).getName() + "//*\"");
+ searchQueryService.expectNoResultsFromQuery(query, testUser);
+ }
+
+ /**
+ * Verify that removing a node D (fD) having a secondary children relationship will remove the relationships and update PATH index in ES.
+ * Test changes below folders hierarchy from:
+ *
+ * DL
+ * += fQ
+ * +
+ * |
+ * += fE += fF
+ * +
+ * |
+ * += fR
+ *
+ * into:
+ *
+ * DL
+ * += fQ
+ * += fR
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithDeletedSecondaryParentNode()
+ {
+ // given
+ STEP("Create two nested folders (E and F) in Document Library.");
+ Folder folderE = folders().createFolder( "E");
+ Folder folderF = folderE.createNestedFolder( "F");
+ STEP("Make folderE a secondary children of folderQ and folderR a secondary children of folderE.");
+ folders(Q).addSecondaryChild(folderE);
+ folderE.addSecondaryChild(folders(R));
+
+ STEP("Verify that searching by PATH and folderQ will find nodes: folderE, folderF and folderR.");
+ SearchRequest queryPathQ = req("PATH:\"//cm:" + folders(Q).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathQ, testUser,
+ // secondary path
+ folderE.getName(),
+ folderF.getName(),
+ folders(R).getName());
+ STEP("Verify that searching by PATH and folderE will find its primary and secondary children: folderF and folderR.");
+ SearchRequest queryPathD = req("PATH:\"//cm:" + folderE.getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathD, testUser,
+ // primary path
+ folderF.getName(),
+ // secondary path
+ folders(R).getName());
+
+ // when
+ STEP("Delete folderE and verify that PATH was updated for nodes folderQ and folderR.");
+ folders().delete(folderE);
+
+ // then
+ searchQueryService.expectNoResultsFromQuery(queryPathQ, testUser);
+ searchQueryService.expectNoResultsFromQuery(queryPathD, testUser);
+ }
+
+ /**
+ * Verify that moving folder D (fD) containing secondary children from hierarchy:
+ *
+ * DL
+ * += fQ += fD +- fP += file
+ * += fR
+ *
+ * to:
+ *
+ * DL
+ * += fQ
+ * += fR += fD +- fP += file
+ *
+ * will update PATH index in ES.
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryPathWithMovedSecondaryParentNode()
+ {
+ // given
+ STEP("Create folderD inside folderQ, and add folderP as a secondary child.");
+ Folder folderD = folders(Q).createNestedFolder( "D");
+ folderD.addSecondaryChild(folders(P));
+ folders(M).addSecondaryChild(folderD);
+
+ STEP("Verify that searching by PATH and folderD will find nodes: folderP and file.");
+ SearchRequest queryPathD = req("PATH:\"//cm:" + folderD.getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathD, testUser,
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+ STEP("Verify that searching by PATH and folderQ will find nodes: folderD, folderP and file.");
+ SearchRequest queryPathQ = req("PATH:\"//cm:" + folders(Q).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathQ, testUser,
+ // primary path
+ folderD.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+
+ // when
+ STEP("Move folderD from folderQ to folderR.");
+ folderD.moveTo(folders(R));
+
+ // then
+ STEP("Verify that search result for PATH and folderD didn't change.");
+ searchQueryService.expectResultsFromQuery(queryPathD, testUser,
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+ STEP("Verify that searching by PATH and folderQ doesn't return any node anymore.");
+ searchQueryService.expectNoResultsFromQuery(queryPathQ, testUser);
+ STEP("Verify that searching by PATH and folderR will find nodes: folderD, folderP and file.");
+ SearchRequest queryPathR = req("PATH:\"//cm:" + folders(R).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathR, testUser,
+ // primary path
+ folderD.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+
+ STEP("Clean-up - delete folderD.");
+ folders().delete(folderD);
+ }
+
+ /**
+ * Verify that copying folder will also result in copying folder's secondary children and update PATH index in ES.
+ * Test changes below folders hierarchy:
+ *
+ * DL
+ * += fS += fG += fH
+ * +
+ * /
+ * += fP += file
+ * += fT
+ *
+ * into:
+ *
+ * DL
+ * += fS += fG += fH
+ * +
+ * /
+ * += fP += file
+ * \
+ * +
+ * += fT += fG-c += fH-c
+ *
+ */
+ @Test(groups = TestGroup.SEARCH)
+ public void testSecondaryParentWithCopiedSecondaryParentNode()
+ {
+ // given
+ STEP("Create nested folders (G and H) inside folderS and folderT in Document Library. Make folderP a secondary child of folderG.");
+ Folder folderG = folders(S).createNestedFolder( "G");
+ Folder folderH = folderG.createNestedFolder("H");
+ Folder folderT = folders().createFolder("T");
+ folderG.addSecondaryChild(folders(P));
+
+ STEP("Verify that searching by PATH and folderG will find nodes: folderH, folderP and file.");
+ SearchRequest queryPathG = req("PATH:\"//cm:" + folderG.getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathG, testUser,
+ // primary path
+ folderH.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+ STEP("Verify that searching by PATH and folderS will find nodes: folderG, folderH, folderP and file.");
+ SearchRequest queryPathS = req("PATH:\"//cm:" + folders(S).getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathS, testUser,
+ // primary path
+ folderG.getName(),
+ folderH.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+
+ // when
+ STEP("Copy folderG with its content to folderT.");
+ Folder folderGCopy = folderG.copyTo(folderT);
+
+ // then
+ STEP("Verify that search result for PATH and folderS didn't change.");
+ searchQueryService.expectResultsFromQuery(queryPathS, testUser,
+ // primary path
+ folderH.getName(),
+ folderG.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+ STEP("Verify that searching by PATH and folderS/folderG will find nodes: folderH, folderP and file in P.");
+ SearchRequest queryPathSG = req("PATH:\"//cm:" + folders(S).getName() + "/cm:" + folderG.getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathSG, testUser,
+ // primary path
+ folderH.getName(),
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+ STEP("Verify that folderG was copied with secondary parent-child relationship and PATH reflects that - search by folderT/folderGCopy should find nodes: folderH, folderP and file in P.");
+ SearchRequest queryPathTGCopy = req("PATH:\"//cm:" + folderT.getName() + "/cm:" + folderGCopy.getName() + "//*\"");
+ searchQueryService.expectResultsFromQuery(queryPathTGCopy, testUser,
+ // primary path
+ folderH.getName(), // the same name as folderH-copy
+ // secondary path
+ folders(P).getName(),
+ fileInP.getName());
+
+ STEP("Clean-up - delete folderG and folderT (with G's copy).");
+ folders().delete(folderG);
+ folders().delete(folderT);
+ }
+}