diff --git a/packaging/tests/tas-restapi/src/main/resources/default.properties b/packaging/tests/tas-restapi/src/main/resources/default.properties
index 268003078d..4b5cc1e420 100644
--- a/packaging/tests/tas-restapi/src/main/resources/default.properties
+++ b/packaging/tests/tas-restapi/src/main/resources/default.properties
@@ -16,6 +16,10 @@ solr.port=8083
#Solr Indexing Time
solrWaitTimeInSeconds=20
+## CMIS settings - required by search E2E tests
+cmis.binding=browser
+cmis.basePath=/alfresco/api/-default-/public/cmis/versions/1.1/${cmis.binding}
+
# credentials
admin.user=admin
admin.password=admin
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractE2EFunctionalTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractE2EFunctionalTest.java
new file mode 100644
index 0000000000..8737eaa765
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractE2EFunctionalTest.java
@@ -0,0 +1,560 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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
+ * Mirrors the structure of {@code AbstractE2EFunctionalTest} from the InsightEngine repo, which is the source of truth for these tests.
+ */
+@ContextConfiguration("classpath:alfresco-restapi-context.xml")
+@SuppressWarnings({"PMD.CouplingBetweenObjects", "PMD.GodClass", "PMD.TooManyMethods"})
+public abstract class AbstractE2EFunctionalTest extends AbstractTestNGSpringContextTests
+{
+ private static final Logger LOGGER = LogFactory.getLogger();
+
+ /** Maximum number of times a wait-for-indexing query will be retried before giving up. */
+ protected static final int SEARCH_MAX_ATTEMPTS = 120;
+
+ @Autowired
+ protected TasProperties properties;
+
+ @Autowired
+ protected ServerHealth serverHealth;
+
+ @Autowired
+ protected DataSite dataSite;
+
+ @Autowired
+ protected DataContent dataContent;
+
+ @Autowired
+ protected RestWrapper restClient;
+
+ @Autowired
+ protected CmisWrapper cmisApi;
+
+ @Autowired
+ protected DataUser dataUser;
+
+ protected UserModel testUser;
+ protected UserModel adminUserModel;
+ protected UserModel testUser2;
+
+ protected SiteModel testSite;
+ protected SiteModel testSite2;
+
+ /** Random unique string derived from the test site name; used to build unique file titles. */
+ @SuppressWarnings({"PMD.MutableStaticState", "PMD.FieldNamingConventions"})
+ protected static String unique_searchString;
+
+ /** Search query language. {@link #toString()} returns the lower-case identifier expected by Search API. */
+ protected enum SearchLanguage
+ {
+ CMIS, AFTS;
+
+ @Override
+ @SuppressWarnings("PMD.UseLocaleWithCaseConversions")
+ public String toString()
+ {
+ return name().toLowerCase();
+ }
+ }
+
+ @BeforeClass(alwaysRun = true)
+ public void setup()
+ {
+ serverHealth.assertServerIsOnline();
+
+ adminUserModel = dataUser.getAdminUser();
+ testUser = dataUser.createRandomTestUser("UserSearch");
+
+ testSite = new SiteModel(RandomData.getRandomName("SiteSearch"));
+ testSite.setVisibility(Visibility.PRIVATE);
+ testSite = dataSite.usingUser(testUser).createSite(testSite);
+
+ unique_searchString = testSite.getTitle().replace("SiteSearch", "Unique");
+ }
+
+ @BeforeMethod(alwaysRun = true)
+ public void showStartTestInfo(Method method)
+ {
+ LOGGER.info(String.format("*** STARTING Test: [%s] ***", method.getName()));
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void showEndTestInfo(Method method)
+ {
+ LOGGER.info(String.format("*** ENDING Test: [%s] ***", method.getName()));
+ }
+
+ // -------------------------------------------------------------------------
+ // Custom content model lifecycle
+ // -------------------------------------------------------------------------
+
+ /** Deploys a custom content model from the given classpath path. Path must end with {@code -model.xml}. */
+ public boolean deployCustomModel(String path)
+ {
+ if (path == null || !path.endsWith("-model.xml"))
+ {
+ return false;
+ }
+ try
+ {
+ dataContent.usingAdmin().deployContentModel(path);
+ return true;
+ }
+ catch (Exception e)
+ {
+ LOGGER.warn("Error loading custom model: " + path, e);
+ return false;
+ }
+ }
+
+ /** Deactivates a deployed custom content model via the private CMM REST API. */
+ public boolean deactivateCustomModel(String modelFileName)
+ {
+ try
+ {
+ CustomContentModel model = new CustomContentModel();
+ model.setName(fileNameToModelLocalName(modelFileName));
+ restClient.authenticateUser(adminUserModel).withPrivateAPI().usingCustomModel(model).deactivateModel();
+ return true;
+ }
+ catch (Exception e)
+ {
+ LOGGER.warn("Error deactivating custom model: " + modelFileName, e);
+ return false;
+ }
+ }
+
+ /** Deletes a deactivated custom content model via the private CMM REST API. */
+ public boolean deleteCustomModel(String modelFileName)
+ {
+ try
+ {
+ CustomContentModel model = new CustomContentModel();
+ model.setName(fileNameToModelLocalName(modelFileName));
+ restClient.authenticateUser(adminUserModel).withPrivateAPI().usingCustomModel(model).deleteModel();
+ return true;
+ }
+ catch (Exception e)
+ {
+ LOGGER.warn("Error deleting custom model: " + modelFileName, e);
+ return false;
+ }
+ }
+
+ /**
+ * Converts a model file name like {@code "sharding-content-model.xml"} (or {@code "model/sharding-content-model.xml"}) into its CamelCase local name {@code "ShardingContentModel"} as expected by the private CMM REST API.
+ */
+ @SuppressWarnings({"PMD.UseIndexOfChar", "PMD.UseLocaleWithCaseConversions"})
+ private String fileNameToModelLocalName(String modelFileName)
+ {
+ String base = modelFileName.contains("/")
+ ? modelFileName.substring(modelFileName.lastIndexOf("/") + 1)
+ : modelFileName;
+ if (base.endsWith(".xml"))
+ {
+ base = base.substring(0, base.length() - 4);
+ }
+ StringBuilder sb = new StringBuilder();
+ for (String part : base.split("-"))
+ {
+ if (!part.isEmpty())
+ {
+ sb.append(Character.toUpperCase(part.charAt(0))).append(part.substring(1).toLowerCase());
+ }
+ }
+ return sb.toString();
+ }
+
+ protected DataUser getDataUser()
+ {
+ return dataUser;
+ }
+
+ // -------------------------------------------------------------------------
+ // Query helpers
+ // -------------------------------------------------------------------------
+
+ /** Executes a {@link SearchRequest} as {@link #testUser}. */
+ protected SearchResponse query(SearchRequest query)
+ {
+ return restClient.authenticateUser(testUser).withSearchAPI().search(query);
+ }
+
+ /** Runs a simple AFTS query as admin and returns the response. */
+ public SearchResponse query(String queryString)
+ {
+ return queryAsUser(dataUser.getAdminUser(), queryString);
+ }
+
+ /** Runs a search with the given query and highlight model as {@link #testUser}. */
+ protected SearchResponse query(RestRequestQueryModel queryReq, RestRequestHighlightModel highlight)
+ {
+ SearchRequest searchReq = new SearchRequest(queryReq);
+ searchReq.setHighlight(highlight);
+ return restClient.authenticateUser(testUser).withSearchAPI().search(searchReq);
+ }
+
+ /** Runs an AFTS query as the given user. */
+ protected SearchResponse queryAsUser(UserModel user, String queryString)
+ {
+ SearchRequest searchRequest = new SearchRequest();
+ RestRequestQueryModel queryModel = new RestRequestQueryModel();
+ queryModel.setQuery(queryString);
+ searchRequest.setQuery(queryModel);
+ return restClient.authenticateUser(user).withSearchAPI().search(searchRequest);
+ }
+
+ /** Runs the given query and spellcheck model as the given user. */
+ protected SearchResponse queryAsUser(UserModel user, RestRequestQueryModel queryModel, RestRequestSpellcheckModel spellcheckQuery)
+ {
+ SearchRequest searchRequest = new SearchRequest();
+ searchRequest.setQuery(queryModel);
+ searchRequest.setSpellcheck(spellcheckQuery);
+ return restClient.authenticateUser(user).withSearchAPI().search(searchRequest);
+ }
+
+ /** Runs the given query as the given user, optionally with pagination. */
+ protected SearchResponse queryAsUser(UserModel user, RestRequestQueryModel queryModel, Pagination paging)
+ {
+ SearchRequest searchRequest = new SearchRequest();
+ searchRequest.setQuery(queryModel);
+ if (paging != null)
+ {
+ searchRequest.setPaging(paging);
+ }
+ return restClient.authenticateUser(user).withSearchAPI().search(searchRequest);
+ }
+
+ /** Builds a {@link SearchRequest} from a single AFTS term. */
+ protected SearchRequest createQuery(String term)
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery(term);
+ query.setQuery(queryReq);
+ return query;
+ }
+
+ // -------------------------------------------------------------------------
+ // Wait-for-indexing helpers
+ // -------------------------------------------------------------------------
+
+ /** Waits using a free-form query (no field prefix injected). */
+ public boolean waitForIndexing(String userQuery, boolean expectedInResults)
+ {
+ return waitForIndexing(null, userQuery, expectedInResults);
+ }
+
+ /** Waits for {@code name:'userQuery'} (metadata is indexed before content). */
+ public boolean waitForMetadataIndexing(String userQuery, boolean expectedInResults)
+ {
+ return waitForIndexing("name", userQuery, expectedInResults);
+ }
+
+ /** Waits for {@code cm:content:'userQuery'} (content indexing can be slower than metadata). */
+ public boolean waitForContentIndexing(String userQuery, boolean expectedInResults)
+ {
+ return waitForIndexing("cm:content", userQuery, expectedInResults);
+ }
+
+ private boolean waitForIndexing(String fieldName, String userQuery, boolean expectedInResults)
+ {
+ String query = (fieldName == null) ? userQuery : String.format("%s:'%s'", fieldName, userQuery);
+ return isContentInSearchResults(query, null, expectedInResults);
+ }
+
+ /**
+ * Polls the search API until the expected content appears or is absent from the results, or until {@link #SEARCH_MAX_ATTEMPTS} attempts have elapsed. Uses the configured Solr wait time per retry attempt.
+ */
+ public boolean isContentInSearchResults(String userQuery, String contentToFind, boolean expectedInResults)
+ {
+ String contentName = (contentToFind == null) ? "" : contentToFind;
+ SearchRequest searchRequest = createQuery(userQuery);
+ final int ignoreRuntimeExceptionThreshold = SEARCH_MAX_ATTEMPTS / 10 + 1;
+
+ for (int searchCount = 0; searchCount < SEARCH_MAX_ATTEMPTS; searchCount++)
+ {
+ try
+ {
+ if (expectedInResults == isContentFoundWithRequest(searchRequest, contentName))
+ {
+ return true;
+ }
+ }
+ catch (EmptyJsonResponseException ignore)
+ {
+ // Empty response — try again
+ }
+ catch (RuntimeException runtimeException)
+ {
+ if (searchCount > ignoreRuntimeExceptionThreshold)
+ {
+ throw runtimeException;
+ }
+ LOGGER.warn("Ignoring initial Search API failure.", runtimeException);
+ }
+ finally
+ {
+ Utility.waitToLoopTime(properties.getSolrWaitTimeInSeconds(),
+ "Wait For Indexing. Retry Attempt: " + (searchCount + 1));
+ }
+ }
+ return false;
+ }
+
+ @SuppressWarnings("PMD.AvoidThrowingRawExceptionTypes")
+ private boolean isContentFoundWithRequest(SearchRequest searchRequest, String contentName)
+ {
+ SearchResponse response = query(searchRequest);
+ if (restClient.getStatusCode().matches(String.valueOf(HttpStatus.OK.value())))
+ {
+ return isContentInSearchResponse(response, contentName);
+ }
+ String responseBody = restClient.onResponse().getResponse().body().prettyPrint();
+ throw new RuntimeException("API returned status code: " + restClient.getStatusCode()
+ + " Expected: " + HttpStatus.OK.value() + "; Response body: " + responseBody);
+ }
+
+ /** True if a result entry's name matches {@code contentName} (case-insensitive), or if {@code contentName} is blank. */
+ public boolean isContentInSearchResponse(SearchResponse response, String contentName)
+ {
+ return response.getEntries().stream()
+ .map(entry -> entry.getModel().getName())
+ .anyMatch(name -> name.equalsIgnoreCase(contentName) || contentName.isBlank());
+ }
+
+ // -------------------------------------------------------------------------
+ // testSearchQuery* helpers
+ // -------------------------------------------------------------------------
+
+ /** Runs a search and (optionally) asserts the {@code count} in the pagination response. Defaults to AFTS. */
+ protected SearchResponse testSearchQuery(String query, Integer expectedCount)
+ {
+ return testSearchQuery(query, expectedCount, SearchLanguage.AFTS);
+ }
+
+ /** Runs a search using the given language and (optionally) asserts the {@code count} in the pagination response. */
+ protected SearchResponse testSearchQuery(String query, Integer expectedCount, SearchLanguage queryLanguage)
+ {
+ SearchResponse response = performSearch(testUser, query, queryLanguage, getDefaultPagingOptions());
+ if (expectedCount != null)
+ {
+ restClient.onResponse().assertThat().body("list.pagination.count", Matchers.equalTo(expectedCount));
+ }
+ return response;
+ }
+
+ /** Runs a search and asserts that the returned entry names exactly match {@code expectedNames} in the given order. */
+ protected SearchResponse testSearchQueryOrdered(String query, List expectedNames, SearchLanguage queryLanguage)
+ {
+ SearchResponse response = performSearch(testUser, query, queryLanguage, getDefaultPagingOptions());
+ List names = response.getEntries().stream()
+ .map(s -> s.getModel().getName())
+ .collect(Collectors.toList());
+ assertEquals(names, expectedNames,
+ "Unexpected results for query: " + query + " Expected: " + expectedNames + " but got " + names);
+ return response;
+ }
+
+ /** Convenience overload using AFTS. */
+ protected SearchResponse testSearchQueryUnordered(String query, Set expectedNames)
+ {
+ return testSearchQueryUnordered(query, expectedNames, SearchLanguage.AFTS);
+ }
+
+ /** Runs a search and asserts that the returned entry names equal {@code expectedNames} as a set (order ignored). */
+ protected SearchResponse testSearchQueryUnordered(String query, Set expectedNames, SearchLanguage queryLanguage)
+ {
+ SearchResponse response = performSearch(testUser, query, queryLanguage, getDefaultPagingOptions());
+ Set names = response.getEntries().stream()
+ .map(s -> s.getModel().getName())
+ .collect(Collectors.toSet());
+ assertEquals(names, expectedNames, "Unexpected results for query: " + query);
+ return response;
+ }
+
+ protected SearchResponse performSearch(UserModel asUser, String query, SearchLanguage queryLanguage, Pagination paging)
+ {
+ RestRequestQueryModel queryModel = new RestRequestQueryModel();
+ queryModel.setQuery(query);
+
+ UserModel user = ofNullable(asUser).orElse(testUser);
+ if (queryLanguage != null)
+ {
+ queryModel.setLanguage(queryLanguage.toString());
+ }
+ return queryAsUser(user, queryModel, paging);
+ }
+
+ private Pagination getDefaultPagingOptions()
+ {
+ Pagination paging = new Pagination();
+ paging.setSkipCount(0);
+ paging.setMaxItems(100);
+ return paging;
+ }
+
+ /** Builds a pagination object from optional {@code skipCount} / {@code maxItems}. */
+ @SuppressWarnings("PMD.LinguisticNaming")
+ protected Pagination setPaging(Integer skipCount, Integer maxItems)
+ {
+ Pagination paging = new Pagination();
+ if (skipCount != null)
+ {
+ paging.setSkipCount(skipCount);
+ }
+ if (maxItems != null)
+ {
+ paging.setMaxItems(maxItems);
+ }
+ return paging;
+ }
+
+ /**
+ * Polls a CMIS query until {@code totalItems >= expectedCount} or {@link #SEARCH_MAX_ATTEMPTS} attempts have elapsed. Useful when a test needs to wait for the CMIS index to catch up to AFTS name-based indexing (the two can have different lag).
+ *
+ * @param asUser
+ * user to run the query as
+ * @param cmisQuery
+ * a CMIS query string (e.g. {@code "select * from cmis:document where IN_FOLDER('')"})
+ * @param expectedCount
+ * the minimum {@code totalItems} required before returning
+ * @return {@code true} if the expected count was reached, {@code false} if all attempts were exhausted
+ */
+ public boolean waitForCmisSearchCount(UserModel asUser, String cmisQuery, int expectedCount)
+ {
+ for (int attempt = 0; attempt < SEARCH_MAX_ATTEMPTS; attempt++)
+ {
+ SearchResponse response = performSearch(asUser, cmisQuery, SearchLanguage.CMIS, setPaging(0, 1000));
+ if (response != null && !response.isEmpty()
+ && response.getPagination().getTotalItems() >= expectedCount)
+ {
+ return true;
+ }
+ Utility.waitToLoopTime(properties.getSolrWaitTimeInSeconds(),
+ "Waiting for CMIS folder index. Attempt: " + (attempt + 1));
+ }
+ return false;
+ }
+
+ // -------------------------------------------------------------------------
+ // Spellcheck helpers
+ // -------------------------------------------------------------------------
+
+ /**
+ * Builds and runs a spellcheck-enabled search request:
+ *
+ *
+ * {
+ * "query": { "query": "<query>", "userQuery": "<userQuery>" },
+ * "spellcheck": { "query": "<userQuery>" }
+ * }
+ *
+ *
+ * If {@code user} is {@code null}, {@link #testUser} is used.
+ */
+ @SuppressWarnings("PMD.MethodNamingConventions")
+ protected SearchResponse SearchSpellcheckQuery(UserModel user, String query, String userQuery)
+ {
+ RestRequestSpellcheckModel spellCheck = new RestRequestSpellcheckModel();
+ spellCheck.setQuery(userQuery);
+
+ UserModel searchUser = ofNullable(user).orElse(testUser);
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery(query);
+ queryReq.setUserQuery(userQuery);
+ return queryAsUser(searchUser, queryReq, spellCheck);
+ }
+
+ /**
+ * Asserts the {@code spellCheck} object on a search response context:
+ *
+ * If {@code spellCheckType} is {@code null}, asserts the {@code spellCheck} field is null.
+ * Otherwise asserts {@code type} equals {@code spellCheckType}.
+ * If {@code spellCheckSuggestion} is non-null, asserts it appears in {@code suggestions}.
+ *
+ */
+ @SuppressWarnings("PMD.UnitTestShouldUseTestAnnotation")
+ public void testSearchSpellcheckResponse(SearchResponse response, String spellCheckType, String spellCheckSuggestion)
+ {
+ if (spellCheckType != null)
+ {
+ response.getContext().assertThat().field("spellCheck").isNotEmpty();
+ response.getContext().getSpellCheck().assertThat().field("type").is(spellCheckType);
+ }
+ else
+ {
+ response.getContext().assertThat().field("spellCheck").isNull();
+ }
+
+ if (spellCheckSuggestion != null)
+ {
+ response.getContext().assertThat().field("spellCheck").isNotEmpty();
+ response.getContext().getSpellCheck().assertThat().field("suggestions").contains(spellCheckSuggestion);
+ }
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchExactTermTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchExactTermTest.java
new file mode 100644
index 0000000000..119c78b471
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchExactTermTest.java
@@ -0,0 +1,156 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 > exactSearchData = asList(
+ of("name", "Running",
+ "description", "Running is a sport is a nice activity",
+ "content", "when you are running you are doing an amazing sport",
+ "title", "Running jumping"),
+ of("name", "Run",
+ "description", "you are supposed to run jump",
+ "content", "after many runs you are tired and if you jump it happens the same",
+ "title", "Run : a philosophy"),
+ of("name", "Poetry",
+ "description", "a document about poetry and jumpers",
+ "content", "poetry is unrelated to sport",
+ "title", "Running jumping twice jumpers"),
+ of("name", "Jump",
+ "description", "a document about jumps",
+ "content", "runnings jumpings",
+ "title", "Running"),
+ of("name", "Running jumping",
+ "description", "runners jumpers runs everywhere",
+ "content", "run is Good as jump",
+ "title", "Running the art of jumping"));
+
+ List createdFileModels = new ArrayList<>();
+ range(0, exactSearchData.size()).forEach(id -> {
+ Map record = exactSearchData.get(id);
+
+ Map properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:tok:document");
+ properties.put(PropertyIds.NAME, record.get("name"));
+ properties.put("cm:title", record.get("title"));
+ properties.put("cm:description", record.get("description"));
+ properties.put("tok:true", record.get("title")); // tokenized copy
+ properties.put("tok:false", record.get("title")); // non-tokenized copy
+ properties.put("tok:both", record.get("title")); // both copy
+ properties.put(PropertyIds.SECONDARY_OBJECT_TYPE_IDS, List.of("P:cm:titled"));
+
+ FileModel fileModel = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, record.get("content"));
+ fileModel.setName(record.get("name"));
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder)
+ .createFile(fileModel, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ createdFileModels.add(fileModel);
+ });
+
+ waitForContentIndexing("Good", true);
+ }
+
+ @BeforeClass(alwaysRun = true)
+ public void dataPreparation() throws Exception
+ {
+ serverHealth.assertServerIsOnline();
+
+ deployCustomModel("tokenised-model.xml");
+
+ FolderModel testFolder = dataContent.usingSite(testSite).usingUser(testUser).createFolder();
+ prepareExactSearchData(testFolder);
+
+ // date range calculation
+ Date today = new Date();
+ LocalDateTime yesterday = today.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime().plusDays(-1);
+ fromDate = QUERY_DATE_FORMAT.format(Date.from(yesterday.atZone(ZoneId.systemDefault()).toInstant()));
+ LocalDateTime tomorrow = today.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime().plusDays(1);
+ toDate = QUERY_DATE_FORMAT.format(Date.from(tomorrow.atZone(ZoneId.systemDefault()).toInstant()));
+ }
+
+ protected void assertResponseCardinality(String query, int num)
+ {
+ SearchResponse response = queryAsUser(testUser, query);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), num, query);
+ }
+
+ protected void assertException(String query)
+ {
+ queryAsUser(testUser, query);
+ Assert.assertTrue(
+ restClient.getStatusCode().equals(String.valueOf(HttpStatus.NOT_IMPLEMENTED.value())) ||
+ restClient.getStatusCode().equals(String.valueOf(HttpStatus.INTERNAL_SERVER_ERROR.value())),
+ "Status code is not as expected.");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchServicesE2ETest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchServicesE2ETest.java
new file mode 100644
index 0000000000..72a7b7f26c
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/AbstractSearchServicesE2ETest.java
@@ -0,0 +1,161 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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
+ * Preparing the data to index.
+ * Polling the search API until results are present.
+ *
+ *
+ * Mirrors the InsightEngine {@code AbstractSearchServicesE2ETest}: a thin specialisation of {@link AbstractE2EFunctionalTest} that adds the standard "search services" sample data set. All Spring context, autowires, common test user/site setup and generic search/query/wait/ spellcheck helpers are inherited from {@link AbstractE2EFunctionalTest}.
+ */
+@SuppressWarnings({"PMD.LongVariable", "PMD.OneDeclarationPerLine"})
+public abstract class AbstractSearchServicesE2ETest extends AbstractE2EFunctionalTest
+{
+ private static final String SEARCH_DATA_SAMPLE_FOLDER = "FolderSearch";
+
+ private static final int MAX_ATTEMPTS_TO_RETRY_QUERY = 10;
+ private static final int MAX_WAIT_IN_SECONDS_BEFORE_RETRY_QUERY = 5;
+ private static final int MAX_ATTEMPTS_TO_READ_RESPONSE = 10;
+ private static final int MAX_WAIT_IN_SECONDS_BEFORE_REREAD_RESPONSE = 2;
+
+ protected FileModel file, file2, file3, file4;
+ protected FolderModel folder;
+
+ /**
+ * Creates the standard test data structure used across search tests:
+ *
+ *
+ * |- FolderSearch
+ * |-- pangram.txt
+ * |-- cars.PDF
+ * |-- alfresco.docx
+ * |-- <uniqueFileName>.ODT
+ *
+ */
+ public void searchServicesDataPreparation()
+ {
+ folder = new FolderModel(SEARCH_DATA_SAMPLE_FOLDER);
+ dataContent.usingUser(testUser).usingSite(testSite).createFolder(folder);
+
+ String title = "Title: " + unique_searchString;
+ String description = "Description: File is created for search tests by Author: " + unique_searchString + " . ";
+
+ file = new FileModel("pangram.txt", "pangram" + title, description, FileType.TEXT_PLAIN,
+ description + " The quick brown fox jumps over the lazy dog");
+
+ file2 = new FileModel("cars.PDF", "cars", description, FileType.PDF,
+ "The landrover discovery is not a sports car");
+
+ file3 = new FileModel("alfresco.docx", "alfresco", "alfresco", FileType.TEXT_PLAIN,
+ "Alfresco text file for search ");
+
+ file4 = new FileModel(unique_searchString + ".ODT", "uniquee" + title, description, FileType.TEXT_PLAIN,
+ "Unique text file for search ");
+
+ of(file, file2, file3, file4).forEach(
+ f -> dataContent.usingUser(testUser).usingSite(testSite).usingResource(folder).createContent(f));
+
+ waitForMetadataIndexing(file.getName(), true);
+ waitForMetadataIndexing(file2.getName(), true);
+ waitForMetadataIndexing(file3.getName(), true);
+ waitForMetadataIndexing(file4.getName(), true);
+ }
+
+ /**
+ * Creates a file with the provided text in cm:name, cm:title, cm:description and cm:content (under {@link #folder} of {@link #testSite}) and waits for the content to be indexed.
+ */
+ protected FileModel createFileWithProvidedText(String filename, String providedText) throws InterruptedException
+ {
+ String title = "Title: File containing " + providedText;
+ String description = "Description: Contains provided string: " + providedText;
+ FileModel uniqueFile = new FileModel(filename, title, description, FileType.TEXT_PLAIN,
+ "The content " + providedText + " is a provided string");
+ dataContent.usingUser(testUser).usingSite(testSite).usingResource(folder).createContent(uniqueFile);
+ Assert.assertTrue(waitForContentIndexing(providedText, true));
+ return uniqueFile;
+ }
+
+ /**
+ * Repeats the query until the response status is OK and the entries list is non-empty, up to {@link #MAX_ATTEMPTS_TO_READ_RESPONSE} re-reads after a successful status.
+ */
+ protected SearchResponse queryUntilResponseEntriesListNotEmpty(UserModel user, String queryString)
+ {
+ SearchResponse response = queryUntilStatusIsOk(user, queryString);
+ if (restClient.getStatusCode().matches(String.valueOf(HttpStatus.OK.value())))
+ {
+ for (int readAttempts = 0; readAttempts < MAX_ATTEMPTS_TO_READ_RESPONSE; readAttempts++)
+ {
+ if (!response.isEmpty())
+ {
+ return response;
+ }
+ Utility.waitToLoopTime(MAX_WAIT_IN_SECONDS_BEFORE_REREAD_RESPONSE,
+ "Re-reading empty response. Retry Attempt: " + (readAttempts + 1));
+ }
+ }
+ return response;
+ }
+
+ private SearchResponse queryUntilStatusIsOk(UserModel user, String queryString)
+ {
+ // Repeat query until status is OK or query retry limit is hit
+ for (int queryAttempts = 0; queryAttempts < MAX_ATTEMPTS_TO_RETRY_QUERY - 1; queryAttempts++)
+ {
+ try
+ {
+ SearchResponse response = queryAsUser(user, queryString);
+ if (restClient.getStatusCode().matches(String.valueOf(HttpStatus.OK.value())))
+ {
+ return response;
+ }
+ Utility.waitToLoopTime(MAX_WAIT_IN_SECONDS_BEFORE_RETRY_QUERY,
+ "Re-trying query for valid status code. Retry Attempt: " + (queryAttempts + 1));
+ }
+ catch (EmptyJsonResponseException ignore)
+ {
+ // try again
+ }
+ }
+ // Final attempt
+ return queryAsUser(user, queryString);
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ExplicitRoutingTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ExplicitRoutingTest.java
new file mode 100644
index 0000000000..5445c23267
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ExplicitRoutingTest.java
@@ -0,0 +1,97 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 propertiesFirstChild = Map.of(PropertyIds.NAME, file.getName(),
+ PropertyIds.OBJECT_TYPE_ID, "cmis:document",
+ "cmis:secondaryObjectTypeIds", List.of("P:shard:sharding"),
+ "shard:shardId", "0");
+
+ // Create file using shard:shardId (explicit routing)
+ cmisApi.authenticateUser(testUser).usingSite(testSite)
+ .createFile(file, propertiesFirstChild, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ // Wait for file to be indexed
+ assertTrue(isContentInSearchResults(file.getName(), file.getName(), true),
+ "A file using sharding model has not been indexed");
+
+ // Deleting file
+ dataContent.usingSite(testSite).usingUser(testUser).usingResource(file).deleteContent();
+ restClient.withCoreAPI().usingTrashcan().deleteNodeFromTrashcan(file);
+
+ // Deleting sharding model
+ assertTrue(deactivateCustomModel("sharding-content-model.xml"),
+ "failing while deactivating sharding model");
+ assertTrue(deleteCustomModel("sharding-content-model.xml"),
+ "failing while removing sharding model");
+
+ assertTrue(waitForIndexing("TYPE:'" + "shard:shardId" + "'", false),
+ "Indexes are not updated after deactivating a model");
+
+ // Create a file in the parent folder
+ file = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "custom content");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite)
+ .createFile(file,
+ Map.of(PropertyIds.NAME, file.getName(),
+ PropertyIds.OBJECT_TYPE_ID, "cmis:document"),
+ VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ assertTrue(isContentInSearchResults(file.getName(), file.getName(), true),
+ "Indexing is not working after the sharding model has been removed");
+
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetFieldsSearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetFieldsSearchTest.java
new file mode 100644
index 0000000000..eda976f9bb
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetFieldsSearchTest.java
@@ -0,0 +1,253 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 facets = new ArrayList<>();
+
+ facets.add(new RestRequestFacetFieldModel("SITE", "SEARCH.FACET_FIELDS.SITE", 0)); // MinCount = 0
+ facets.add(new RestRequestFacetFieldModel("cm:content.mimetype", "Mimetype", 2)); // MinCount = 2
+
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ // Search query using user who created site
+ SearchResponse response = query(query);
+
+ // Expect MimeType bucket with size 1 is excluded as minCount = 2 won't be reached
+ Assert.assertEquals(response.getContext().getFacetsFields().size(), 1);
+
+ // Expect SITE bucket is included and MinCount defaults to 1
+ RestResultBucketsModel facetFieldList = response.getContext().getFacetsFields().getFirst();
+ Assert.assertEquals(facetFieldList.getLabel(), "SEARCH.FACET_FIELDS.SITE");
+ Assert.assertEquals(facetFieldList.getBuckets().size(), 1);
+
+ FacetFieldBucket bucket1 = facetFieldList.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testSite.getId());
+ bucket1.assertThat().field("filterQuery").contains(testSite.getId());
+ bucket1.assertThat().field("count").is(3); // One folder and 2 files created above
+ }
+
+ @Test
+ public void testSearchWithFacetFieldsMinCountChecks()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("name:" + fname);
+ query.setQuery(queryReq);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+
+ // MinCount not set
+ facets.add(new RestRequestFacetFieldModel("SITE", "SEARCH.FACET_FIELD1.SITE", null)); // MinCount Not set
+ facets.add(new RestRequestFacetFieldModel("cm:content.mimetype", "SEARCH.FACET_FIELD2.Mimetype", 1)); // MinCount = 1
+
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ // Search query using user who created site
+ SearchResponse response = query(query);
+
+ // Expect 2 Facet buckets to be retrieved: MinCount when not set defaults to 1
+ List facetFieldBucketsList = response.getContext().getFacetsFields();
+ Assert.assertEquals(facetFieldBucketsList.size(), 2, "FacetField");
+
+ RestResultBucketsModel facetFieldList = facetFieldBucketsList.getFirst();
+ Assert.assertEquals(facetFieldList.getLabel(), "SEARCH.FACET_FIELD1.SITE");
+
+ FacetFieldBucket bucket1 = facetFieldList.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testSite.getId());
+ bucket1.assertThat().field("filterQuery").contains(testSite.getId());
+ bucket1.assertThat().field("count").is(3);
+
+ // MimeType bucket will be shown with 2 buckets
+ facetFieldList = facetFieldBucketsList.get(1);
+ Assert.assertEquals(facetFieldList.getLabel(), "SEARCH.FACET_FIELD2.Mimetype");
+ Assert.assertEquals(facetFieldList.getBuckets().size(), 2);
+
+ bucket1 = facetFieldList.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is("text/html");
+ bucket1.assertThat().field("filterQuery").contains("text/html");
+ bucket1.assertThat().field("count").is(1);
+ bucket1.assertThat().field("display").is("HTML");
+
+ bucket1 = facetFieldList.getBuckets().get(1);
+ bucket1.assertThat().field("label").is("text/plain");
+ bucket1.assertThat().field("filterQuery").contains("text/plain");
+ bucket1.assertThat().field("count").is(1);
+ bucket1.assertThat().field("display").is("Plain Text");
+ }
+
+ @Test
+ public void testSearchWithFacetFieldsNoFacetsWhenNoAccess()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("name:" + fname);
+ query.setQuery(queryReq);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+
+ facets.add(new RestRequestFacetFieldModel("SITE", "SEARCH.FACET_FIELD1.SITE", null)); // MinCount Not set
+ facets.add(new RestRequestFacetFieldModel("cm:content.mimetype", "SEARCH.FACET_FIELD2.Mimetype", 1)); // MinCount = 1
+
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ // Search query using other user
+ SearchResponse response = restClient.authenticateUser(userWithNoAccess).withSearchAPI().search(query);
+
+ // User has No access to matching content hence no buckets expected
+ Assert.assertNull(response.getContext().getFacetsFields());
+ }
+
+ @Test
+ public void testSearchWithFacetFieldsOnlyFacetsWhereAccess()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("name:" + fname);
+ query.setQuery(queryReq);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+
+ facets.add(new RestRequestFacetFieldModel("SITE", "SEARCH.FACET_FIELD1.SITE", null)); // MinCount Not set
+ facets.add(new RestRequestFacetFieldModel("cm:content.mimetype", "SEARCH.FACET_FIELD2.Mimetype", 1)); // MinCount = 1
+
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ // Search query using user that can access 1 text file
+ SearchResponse response = restClient.authenticateUser(userCanAccessTextFile).withSearchAPI().search(query);
+
+ List facetFieldBucketsList = response.getContext().getFacetsFields();
+ Assert.assertEquals(facetFieldBucketsList.size(), 2);
+
+ // Check FacetField 1
+ RestResultBucketsModel facetFieldList = facetFieldBucketsList.getFirst();
+
+ // User has granular permissions to content within this private site, so expect the Site bucket
+ Assert.assertEquals(facetFieldList.getLabel(), "SEARCH.FACET_FIELD1.SITE");
+
+ FacetFieldBucket bucket1 = facetFieldList.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testSite.getId());
+ bucket1.assertThat().field("filterQuery").contains(testSite.getId());
+ bucket1.assertThat().field("count").is(1);
+
+ // Expect MimeType bucket shows only 1 bucket where user has access to content
+ facetFieldList = facetFieldBucketsList.get(1);
+ Assert.assertEquals(facetFieldList.getLabel(), "SEARCH.FACET_FIELD2.Mimetype");
+ Assert.assertEquals(facetFieldList.getBuckets().size(), 1);
+
+ // User has access to text file alone, so expect bucket for text/plain and not for html content.
+ bucket1 = facetFieldList.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is("text/plain");
+ bucket1.assertThat().field("label").isNot("text/html");
+ bucket1.assertThat().field("filterQuery").contains("text/plain");
+ bucket1.assertThat().field("count").is(1);
+ bucket1.assertThat().field("display").is("Plain Text");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetIntervalSearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetIntervalSearchTest.java
new file mode 100644
index 0000000000..0b7ab5eb12
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetIntervalSearchTest.java
@@ -0,0 +1,186 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 ranges = List.of(facetRangeModel);
+ query.setRanges(ranges);
+ SearchResponse response = query(query);
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().getFirst();
+
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().getFirst();
+ bucket.assertThat().field("label").is("[20 - 40)");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"20\" TO \"40\">");
+ Map metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 2, "Unexpected count for first bucket.");
+ Map info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "20");
+ assertEquals(info.get("end"), "40");
+ assertNull(info.get("count"));
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "false");
+
+ bucket = facetResponseModel.getBuckets().get(1);
+ bucket.assertThat().field("label").is("[40 - 120)");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"40\" TO \"120\">");
+ metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for second bucket.");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "40");
+ assertEquals(info.get("end"), "120");
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "false");
+
+ bucket = facetResponseModel.getBuckets().get(2);
+ bucket.assertThat().field("label").is("[120 - 200]");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"120\" TO \"200\"]");
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for third bucket.");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "120");
+ assertEquals(info.get("end"), "200");
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "true");
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void searchWithRangeHardend()
+ {
+ SearchRequest query = createQuery("* AND SITE:'" + testSite.getId() + "'");
+
+ RestRequestRangesModel facetRangeModel = createRangesModel("content.size", "0", "200", "20");
+ facetRangeModel.setHardend(true);
+ List ranges = List.of(facetRangeModel);
+ query.setRanges(ranges);
+ SearchResponse response = query(query);
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().getFirst();
+
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().getFirst();
+ bucket.assertThat().field("label").is("[20 - 40)");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"20\" TO \"40\">");
+ Map metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 2, "Unexpected count for first bucket.");
+ Map info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "20");
+ assertEquals(info.get("end"), "40");
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "false");
+ assertNull(info.get("count"));
+
+ bucket = facetResponseModel.getBuckets().get(1);
+ bucket.assertThat().field("label").is("[40 - 120)");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"40\" TO \"120\">");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "40");
+ assertEquals(info.get("end"), "120");
+ metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for second bucket.");
+ assertNull(info.get("count"));
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "false");
+
+ bucket = facetResponseModel.getBuckets().get(2);
+ bucket.assertThat().field("label").is("[120 - 200]");
+ bucket.assertThat().field("filterQuery").is("content.size:[\"120\" TO \"200\"]");
+ metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for third bucket.");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "120");
+ assertEquals(info.get("end"), "200");
+ assertNull(info.get("count"));
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "true");
+ }
+
+ /** This test relies on a document created in 2015 existing, probably part of the sample site. */
+ @Test
+ @SuppressWarnings("unchecked")
+ public void searchDateRange()
+ {
+ skipIfSwsdp2015DocMissing();
+
+ SearchRequest query = createQuery("name:A*");
+
+ RestRequestRangesModel facetRangeModel = createRangesModel("created", "2015-09-29T10:45:15.729Z", "2016-09-29T10:45:15.729Z", "+280DAY");
+ List ranges = List.of(facetRangeModel);
+ query.setRanges(ranges);
+ SearchResponse response = query(query);
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().getFirst();
+
+ List buckets = facetResponseModel.getBuckets();
+ assertThat(buckets.size(), is(1));
+
+ RestGenericBucketModel bucket = buckets.getFirst();
+ bucket.assertThat().field("label").is("[2015-09-29T10:45:15.729Z - 2017-04-11T10:45:15.729Z]");
+ bucket.assertThat().field("filterQuery").is("created:[\"2015-09-29T10:45:15.729Z\" TO \"2017-04-11T10:45:15.729Z\"]");
+ bucket.getMetrics().getFirst().assertThat().field("value").is("{count=1}");
+ Map info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "2015-09-29T10:45:15.729Z");
+ assertEquals(info.get("end"), "2017-04-11T10:45:15.729Z");
+ assertNull(info.get("count"), "1");
+ assertEquals(info.get("startInclusive"), "true");
+ assertEquals(info.get("endInclusive"), "true");
+ }
+
+ @Test
+ @SuppressWarnings("PMD.UnitTestShouldIncludeAssert")
+ public void searchDateAndSizeRanges()
+ {
+ SearchRequest query = createQuery("* AND SITE:'" + testSite.getId() + "'");
+ RestRequestRangesModel facetRangeModel = createRangesModel("created", "2015-09-29T10:45:15.729Z", "2016-09-29T10:45:15.729Z", "+280DAY");
+ RestRequestRangesModel facetCountRangeModel = createRangesModel("content.size", "0", "500", "200");
+ List ranges = List.of(facetRangeModel, facetCountRangeModel);
+ query.setRanges(ranges);
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void searchWithRangeAndIncludeUpperBound()
+ {
+ SearchRequest query = createQuery("* AND SITE:'" + testSite.getId() + "'");
+
+ RestRequestRangesModel facetRangeModel = createRangesModel("content.size", "0", "200", "20");
+ List include = List.of("upper");
+ facetRangeModel.setInclude(include);
+ List ranges = List.of(facetRangeModel);
+ query.setRanges(ranges);
+ SearchResponse response = query(query);
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().getFirst();
+
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().getFirst();
+ bucket.assertThat().field("label").is("(20 - 40]");
+ bucket.assertThat().field("filterQuery").is("content.size:<\"20\" TO \"40\"]");
+ Map metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 2, "Unexpected count for first bucket.");
+ Map info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "20");
+ assertEquals(info.get("end"), "40");
+ assertNull(info.get("count"));
+ assertEquals(info.get("startInclusive"), "false");
+ assertEquals(info.get("endInclusive"), "true");
+
+ bucket = facetResponseModel.getBuckets().get(1);
+ bucket.assertThat().field("label").is("(40 - 120]");
+ bucket.assertThat().field("filterQuery").is("content.size:<\"40\" TO \"120\"]");
+ metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for second bucket.");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "40");
+ assertEquals(info.get("end"), "120");
+ assertEquals(info.get("startInclusive"), "false");
+ assertEquals(info.get("endInclusive"), "true");
+
+ bucket = facetResponseModel.getBuckets().get(2);
+ bucket.assertThat().field("label").is("(120 - 200]");
+ bucket.assertThat().field("filterQuery").is("content.size:<\"120\" TO \"200\"]");
+ metric = (Map) bucket.getMetrics().getFirst().getValue();
+ assertEquals(Integer.valueOf(metric.get("count")).intValue(), 1, "Unexpected count for third bucket.");
+ info = (Map) bucket.getBucketInfo();
+ assertEquals(info.get("start"), "120");
+ assertEquals(info.get("end"), "200");
+ assertEquals(info.get("startInclusive"), "false");
+ assertEquals(info.get("endInclusive"), "true");
+ }
+
+ /**
+ * Create a ranges model with the values given.
+ *
+ * @param field
+ * The field to facet on.
+ * @param start
+ * The lowest facet value.
+ * @param end
+ * The highest facet value.
+ * @param gap
+ * The size of the buckets.
+ * @return The facet ranges model.
+ */
+ private RestRequestRangesModel createRangesModel(String field, String start, String end, String gap)
+ {
+ RestRequestRangesModel facetRangeModel = new RestRequestRangesModel();
+ facetRangeModel.setField(field);
+ facetRangeModel.setStart(start);
+ facetRangeModel.setEnd(end);
+ facetRangeModel.setGap(gap);
+ return facetRangeModel;
+ }
+
+ /**
+ * Skips the calling test (via {@link SkipException}) when the repository under test has no document with {@code cm:created} in the 2015-09-29 → 2016-09-29 window. That document is only present when the {@code alfresco-share-services} AMP bootstrapped the SWSDP sample site (see {@code patch.siteLoadPatch.swsdp} in {@code share-services/module-context.xml}).
+ *
+ *
+ * The AMP is bundled by the {@code acs-packaging} Docker image ({@code alfresco/alfresco-content-repository}), but NOT by the base images used in the {@code alfresco-community-repo} and {@code alfresco-enterprise-repo} minimal test stacks. Therefore this date-range facet test is meant to run end-to-end only as part of an {@code acs-packaging} validation; when executed against community/enterprise alone it is skipped instead of failing with an NPE.
+ */
+ private void skipIfSwsdp2015DocMissing()
+ {
+ SearchResponse precheck = queryAsUser(dataUser.getAdminUser(), SAMPLE_2015_DOC_QUERY);
+ boolean hasSample = precheck != null
+ && precheck.getPagination() != null
+ && precheck.getPagination().getTotalItems() != null
+ && precheck.getPagination().getTotalItems() > 0;
+ if (!hasSample)
+ {
+ String reason = "Skipping searchDateRange: no document with cm:created in 2015-09-29 → 2016-09-29 "
+ + "was found. The SWSDP sample site (shipped by the alfresco-share-services AMP via "
+ + "acs-packaging) is not present on this deployment, so the date-range facet cannot be "
+ + "exercised. This test is intended to be run as part of acs-packaging validation.";
+ LOGGER.warn(reason);
+ throw new SkipException(reason);
+ }
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetedSearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetedSearchTest.java
new file mode 100644
index 0000000000..c34b6bbcfb
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FacetedSearchTest.java
@@ -0,0 +1,307 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 facets = new ArrayList<>();
+ facets.add(new FacetQuery("content.size:[0 TO 102400]", "small"));
+ facets.add(new FacetQuery("content.size:[102400 TO 1048576]", "medium"));
+ facets.add(new FacetQuery("content.size:[1048576 TO 16777216]", "large"));
+ query.setFacetQueries(facets);
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("'content.size'"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(true);
+
+ SearchResponse response = query(query);
+
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("facetQueries").isNotEmpty();
+
+ FacetFieldBucket facet = response.getContext().getFacetQueries().getFirst();
+ facet.assertThat().field("label").contains("small").and().field("count").isGreaterThan(0);
+ facet.assertThat().field("label").contains("small").and().field("filterQuery").is("content.size:[0 TO 102400]");
+ Assert.assertEquals(response.getContext().getFacetQueries().size(), 1, "Results with count=0 must be omitted");
+
+ // We don't expect to see the FacetFields if group is being used.
+ Assert.assertNull(response.getContext().getFacetsFields());
+ Assert.assertNull(response.getContext().getFacets());
+ }
+
+ /**
+ * Verify this query is returning the same results for both single server and shard environments.
+ */
+ @Test
+ @SuppressWarnings("PMD.UnitTestShouldIncludeAssert")
+ public void searchWithQueryFacetingCluster()
+ {
+ searchWithQueryFaceting();
+ }
+
+ /**
+ * * Perform a group by faceting, below test groups the facet by group name foo. { "query": { "query": "cars", "language": "afts" }, "facetQueries": [ {"query": "content.size:[o TO 102400]", "label": "small","group":"foo"}, {"query": "content.size:[102400 TO 1048576]", "label": "medium","group":"foo"}, {"query": "content.size:[1048576 TO 16777216]", "label": "large","group":"foo"} ], "facetFields": {"facets": [{"field": "'content.size'"}]} }
+ *
+ * Expected response {"list": { "entries": [... All the results], "pagination": { "maxItems": 100, "hasMoreItems": false, "totalItems": 61, "count": 61, "skipCount": 0 }, "context": { "consistency": {"lastTxId": 512}, //Added below as part of SEARCH-374 "facets": [ { "label": "foo", "buckets": [ { "label": "small", "count": 61, "filterQuery": "content.size:[o TO 102400]"}, { "label": "large", "count": 0, "filterQuery": "content.size:[1048576 TO 16777216]"}, { "label": "medium", "count": 61, "filterQuery": "content.size:[102400 TO 1048576]"} ] } } }}
+ */
+ @Test
+ public void searchQueryFacetingWithGroup()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cars");
+ query.setQuery(queryReq);
+
+ List facets = new ArrayList<>();
+ facets.add(new FacetQuery("content.size:[0 TO 102400]", "small", "foo"));
+ facets.add(new FacetQuery("content.size:[102400 TO 1048576]", "medium", "foo"));
+ facets.add(new FacetQuery("content.size:[1048576 TO 16777216]", "large", "foo"));
+ query.setFacetQueries(facets);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("'content.size'"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+
+ SearchResponse response = query(query);
+
+ // We don't expect to see the FacetQueries if group is being used.
+ Assert.assertNull(response.getContext().getFacetQueries());
+ // Validate the facet field structure is correct.
+ Assert.assertFalse(response.getContext().getFacets().isEmpty());
+ Assert.assertEquals(response.getContext().getFacets().getFirst().getLabel(), "foo");
+
+ RestGenericBucketModel bucket = response.getContext().getFacets().getFirst().getBuckets().getFirst();
+ bucket.assertThat().field("label").isNotEmpty();
+ Assert.assertEquals(bucket.getMetrics().getFirst().getType(), "count");
+ Assert.assertNotEquals(bucket.getMetrics().getFirst().getValue(), "");
+ bucket.assertThat().field("filterQuery").isNotEmpty();
+ response.getContext().getFacets().getFirst().getBuckets().forEach(action -> {
+ switch (action.getLabel())
+ {
+ case "small":
+ Assert.assertEquals(action.getFilterQuery(), "content.size:[0 TO 102400]");
+ break;
+ case "medium":
+ Assert.assertEquals(action.getFilterQuery(), "content.size:[102400 TO 1048576]");
+ break;
+ case "large":
+ Assert.assertEquals(action.getFilterQuery(), "content.size:[1048576 TO 16777216]");
+ break;
+
+ default:
+ throw new TestException("Unexpected value returned");
+ }
+ });
+ }
+
+ /**
+ * { "query": { "query": "*" }, "facetFields": { "facets": [{"field": "cm:mimetype"},{"field": "modifier"}] } }
+ */
+ @Test
+ public void searchWithFactedFields()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:content:" + unique_searchString);
+ query.setQuery(queryReq);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+ facets.add(new RestRequestFacetFieldModel("cm:mimetype"));
+ facets.add(new RestRequestFacetFieldModel("modifier"));
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ SearchResponse response = query(query);
+
+ Assert.assertFalse(response.getContext().getFacetsFields().isEmpty());
+ Assert.assertNull(response.getContext().getFacetQueries());
+ Assert.assertNull(response.getContext().getFacets());
+
+ RestResultBucketsModel model = response.getContext().getFacetsFields().getFirst();
+ Assert.assertEquals(model.getLabel(), "modifier");
+
+ model.assertThat().field("label").is("modifier");
+ FacetFieldBucket bucket1 = model.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testUser.getUsername());
+ bucket1.assertThat().field("display").is("FN-" + testUser.getUsername() + " LN-" + testUser.getUsername());
+ bucket1.assertThat().field("filterQuery").is("modifier:\"" + testUser.getUsername() + "\"");
+ bucket1.assertThat().field("count").is(1);
+ }
+
+ /**
+ * Test that items returned are in the format of generic facets. { "query": { "query": "*" }, "facetFields": { "facets": [{"field": "cm:mimetype"},{"field": "modifier"}] }, "facetFormat":"V2" }
+ */
+ @Test
+ public void searchWithFactedFieldsFacetFormatV2()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:content:" + unique_searchString);
+ query.setQuery(queryReq);
+ query.setFacetFormat("V2");
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+ facets.add(new RestRequestFacetFieldModel("cm:mimetype"));
+ facets.add(new RestRequestFacetFieldModel("modifier"));
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ SearchResponse response = query(query);
+
+ Assert.assertNull(response.getContext().getFacetsFields());
+ Assert.assertNull(response.getContext().getFacetQueries());
+ Assert.assertFalse(response.getContext().getFacets().isEmpty());
+ RestGenericFacetResponseModel model = response.getContext().getFacets().getFirst();
+ Assert.assertEquals(model.getLabel(), "modifier");
+
+ model.assertThat().field("label").is("modifier");
+ RestGenericBucketModel bucket1 = model.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testUser.getUsername());
+ bucket1.assertThat().field("display").is("FN-" + testUser.getUsername() + " LN-" + testUser.getUsername());
+ bucket1.assertThat().field("filterQuery").is("modifier:\"" + testUser.getUsername() + "\"");
+ bucket1.assertThat().field("metrics.entry").is("[null]")
+ .and().field("metrics.type").is("[count]")
+ .and().field("metrics.value").is("[{count=1}]");
+ }
+
+ /**
+ * Test that facet fields return results for single and multivalued fields. { "query": { "query": "cm:addressee:'first'" }, "facetFields": { "facets": [{"field": "cm:addressee"}, {"field": "cm:addressees"}] }, "facetFormat":"V2" }
+ */
+ @Test
+ public void searchWithMultiValuedFieldsFacet()
+ {
+ // Create properties with single (cm:addressee) and multivalued (cm:addressees) values
+ FileModel emailFile = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "Email");
+
+ Map properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "cmis:document");
+ properties.put(PropertyIds.NAME, emailFile.getName());
+ properties.put(PropertyIds.SECONDARY_OBJECT_TYPE_IDS, List.of("P:cm:emailed"));
+ properties.put("cm:addressee", "first");
+ properties.put("cm:addressees", List.of("first", "second"));
+
+ cmisApi.authenticateUser(testUser)
+ .usingSite(testSite)
+ .usingResource(folder)
+ .createFile(emailFile, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ String addresseeQuery = "cm:addressee:'first'";
+ Assert.assertTrue(waitForIndexing(addresseeQuery, true));
+
+ // Search facets fields cm:addressee and cm:addressess
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:addressee:'first'");
+ query.setQuery(queryReq);
+ query.setFacetFormat("V2");
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List facets = new ArrayList<>();
+ facets.add(new RestRequestFacetFieldModel("cm:addressee"));
+ facets.add(new RestRequestFacetFieldModel("cm:addressees"));
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ SearchResponse response = query(query);
+
+ // Verify results
+ Assert.assertNull(response.getContext().getFacetsFields());
+ Assert.assertNull(response.getContext().getFacetQueries());
+ Assert.assertFalse(response.getContext().getFacets().isEmpty());
+
+ // Facets for cm:addressees (multivalued)
+ RestGenericFacetResponseModel model = response.getContext().getFacets().getFirst();
+ Assert.assertEquals(model.getLabel(), "cm:addressees");
+ model.assertThat().field("label").is("cm:addressees");
+ RestGenericBucketModel bucket = model.getBuckets().getFirst();
+ bucket.assertThat().field("label").is("{en}first");
+ bucket.assertThat().field("filterQuery").is("cm:addressees:\"{en}first\"");
+ bucket.assertThat().field("metrics.entry").is("[null]")
+ .and().field("metrics.type").is("[count]")
+ .and().field("metrics.value").is("[{count=1}]");
+ bucket = model.getBuckets().get(1);
+ bucket.assertThat().field("label").is("{en}second");
+ bucket.assertThat().field("filterQuery").is("cm:addressees:\"{en}second\"");
+ bucket.assertThat().field("metrics.entry").is("[null]")
+ .and().field("metrics.type").is("[count]")
+ .and().field("metrics.value").is("[{count=1}]");
+
+ // Facets for cm:addressee (single valued)
+ model = response.getContext().getFacets().get(1);
+ Assert.assertEquals(model.getLabel(), "cm:addressee");
+ model.assertThat().field("label").is("cm:addressee");
+ bucket = model.getBuckets().getFirst();
+ bucket.assertThat().field("label").is("{en}first");
+ bucket.assertThat().field("filterQuery").is("cm:addressee:\"{en}first\"");
+ bucket.assertThat().field("metrics.entry").is("[null]")
+ .and().field("metrics.type").is("[count]")
+ .and().field("metrics.value").is("[{count=1}]");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FieldDefinitionTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FieldDefinitionTest.java
new file mode 100644
index 0000000000..0cd788e668
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/FieldDefinitionTest.java
@@ -0,0 +1,236 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 ...
+ */
+@SuppressWarnings({"PMD.SingularField", "PMD.FieldNamingConventions", "PMD.OneDeclarationPerLine", "PMD.UseDiamondOperator"})
+public class FieldDefinitionTest extends AbstractSearchServicesE2ETest
+{
+
+ private FileModel File1, File2, File3;
+
+ @BeforeClass(alwaysRun = true)
+ public void dataPreparation() throws Exception
+ {
+ dataContent.usingAdmin().deployContentModel("search-2139-model.xml");
+
+ File1 = new FileModel("standard-file1.txt");
+
+ dataContent.usingUser(testUser).usingSite(testSite).createCustomContent(File1, "cmis:document", new CustomObjectTypeProperties());
+
+ cmisApi.authenticateUser(testUser).usingResource(File1).addSecondaryTypes("P:allfieldtypes:text")
+ .updateProperty("allfieldtypes:mltextLOVPartial", "file1")
+ .updateProperty("allfieldtypes:textPatternUnique", "file2")
+ .updateProperty("allfieldtypes:mltextFree", "file3")
+ .updateProperty("allfieldtypes:textLOVPartial", "file4");
+
+ File2 = new FileModel("standard-file2.txt");
+
+ dataContent.usingUser(testUser).usingSite(testSite).createCustomContent(File2, "cmis:document", new CustomObjectTypeProperties());
+
+ cmisApi.authenticateUser(testUser).usingResource(File2).addSecondaryTypes("P:allfieldtypes:text")
+ .updateProperty("allfieldtypes:textFree", "text field definition test")
+ .updateProperty("allfieldtypes:textPatternMany", "mltext field definition test")
+ .updateProperty("allfieldtypes:textLOVWhole", "text field not tokenised")
+ .updateProperty("allfieldtypes:mltextLOVWhole", "mltext field not tokenised");
+
+ File3 = new FileModel("standard-file3.txt");
+
+ dataContent.usingUser(testUser).usingSite(testSite).createCustomContent(File3, "cmis:document",
+ new CustomObjectTypeProperties());
+
+ List mlMultipleValue = new ArrayList();
+ mlMultipleValue.add("oranges");
+ mlMultipleValue.add("apples");
+ mlMultipleValue.add("pears");
+
+ cmisApi.authenticateUser(testUser).usingResource(File3).addSecondaryTypes("P:allfieldtypes:text")
+ .updateProperty("allfieldtypes:multiplemltext", mlMultipleValue);
+
+ waitForMetadataIndexing(File1.getName(), true);
+ waitForMetadataIndexing(File2.getName(), true);
+ waitForMetadataIndexing(File3.getName(), true);
+ }
+
+ // A test to test the text field in the solr schema, using a single word
+ @Test(priority = 1)
+ public void testTextField()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_textPatternUnique:file2");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textLOVPartial:file4");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+ }
+
+ // A test to test the mltext field in the solr schema, using a single word
+ @Test(priority = 2)
+ public void testmlTextField()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_mltextLOVPartial:file1");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_mltextFree:file3");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+ }
+
+ // A test to test the text field in the solr schema, where the field hasn't been defined
+ @Test(priority = 3)
+ public void testTextFieldNotDefined()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_textPatternMany:file1");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+
+ response = queryAsUser(testUser, "allfieldtypes:textNone:file2");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+ }
+
+ // A test to test the mltext field in the solr schema, where the field hasn't been defined
+ @Test(priority = 4)
+ public void testmlTextFieldNotDefined()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_mltextNone:file1");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+
+ response = queryAsUser(testUser, "allfieldtypes_mltextPatternUnique:file2");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+ }
+
+ // A test to test the tokenised text field in the solr schema
+ @Test(priority = 5)
+ public void testTextFieldTokenised()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_textFree:\"text field definition test\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textFree:text");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textFree:\"definition test\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textPatternMany:definition");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+ }
+
+ // A test to test a non tokenised text field in the solr schema
+ @Test(priority = 6)
+ public void testTextFieldNotTokenised()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_textLOVWhole:\"text field not tokenised\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textLOVWhole:text");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+
+ response = queryAsUser(testUser, "allfieldtypes_textLOVWhole:\"field not\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+ }
+
+ // A test to test the tokenised mltext field in the solr schema
+ @Test(priority = 7)
+ public void testmlTextFieldTokenised()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_textPatternMany:\"mltext field definition test\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textPatternMany:mltext");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textPatternMany:\"field definition\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_textPatternMany:field");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+ }
+
+ // A test to test the non tokenised mltext field in the solr schema
+ @Test(priority = 7)
+ public void testmlTextFieldNotTokenised()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_mltextLOVWhole:\"mltext field not tokenised\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_mltextLOVWhole:mltext");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+
+ response = queryAsUser(testUser, "allfieldtypes_mltextLOVWhole:\"not tokenised\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+ }
+
+ // A test having multiple mltext field in the solr schema
+ @Test(priority = 8)
+ public void testmlTextFieldMuliple()
+ {
+ SearchResponse response = queryAsUser(testUser, "allfieldtypes_multiplemltext:\"orange\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_multiplemltext:\"apple\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "allfieldtypes_multiplemltext:\"pear\"");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/PivotFacetedSearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/PivotFacetedSearchTest.java
new file mode 100644
index 0000000000..10e6e42c3f
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/PivotFacetedSearchTest.java
@@ -0,0 +1,264 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("'creator'"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel pivots = new RestRequestPivotModel();
+ pivotModelList.add(pivots);
+ query.setPivots(pivotModelList);
+
+ query(query);
+
+ restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
+ .containsSummary(String.format(RestErrorModel.MANDATORY_PARAM, "pivot key"));
+
+ pivots.setKey("none_like_this");
+
+ query(query);
+
+ restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST)
+ .assertLastError().containsSummary("invalid argument was received")
+ .containsSummary("Pivot parameter none_like_this does not reference");
+ }
+
+ @Test
+ public void searchWithPivoting()
+ {
+ SearchRequest query = createQuery("cars");
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("creator"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+
+ SearchResponse response = query(query);
+ response.getContext().assertThat().field("facetsFields").isNotNull();
+
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel pivots = new RestRequestPivotModel();
+ pivots.setKey("creator");
+ pivotModelList.add(pivots);
+ query.setPivots(pivotModelList);
+ response = query(query);
+
+ // Pivot key has matched facet field so there is no longer a facet fields response
+ assertPivotResponse(response, "creator", null);
+ }
+
+ @Test
+ public void searchWithNestedPivoting()
+ {
+ SearchRequest query = createQuery("cars");
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ RestRequestFacetFieldModel restRequestFacetFieldModel = new RestRequestFacetFieldModel("SITE");
+ restRequestFacetFieldModel.setLabel("site");
+ list.add(restRequestFacetFieldModel);
+ list.add(new RestRequestFacetFieldModel("creator"));
+ list.add(new RestRequestFacetFieldModel("modifier"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel sitepivots = new RestRequestPivotModel();
+ sitepivots.setKey("site");
+ RestRequestPivotModel creatorpivot = new RestRequestPivotModel();
+ creatorpivot.setKey("creator");
+ RestRequestPivotModel modifierpivot = new RestRequestPivotModel();
+ modifierpivot.setKey("modifier");
+ sitepivots.setPivots(Arrays.asList(creatorpivot, modifierpivot));
+ pivotModelList.add(sitepivots);
+ query.setPivots(pivotModelList);
+
+ query(query);
+ restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST)
+ .assertLastError().containsSummary("invalid argument was received")
+ .containsSummary("Currently only 1 nested pivot is supported, you have 2");
+
+ pivotModelList = new ArrayList<>();
+ sitepivots = new RestRequestPivotModel();
+ sitepivots.setKey("site");
+ sitepivots.setPivots(Collections.singletonList(modifierpivot));
+ pivotModelList.add(sitepivots);
+ pivotModelList.add(creatorpivot);
+ query.setPivots(pivotModelList);
+
+ SearchResponse response = query(query);
+ assertPivotResponse(response, "SITE", "site");
+
+ RestGenericFacetResponseModel siteResponse = response.getContext().getFacets().getFirst();
+ RestGenericBucketModel bucket = siteResponse.getBuckets().getFirst();
+ RestGenericFacetResponseModel modifiedResponse = bucket.getFacets().getFirst();
+ modifiedResponse.assertThat().field("type").is("pivot");
+ modifiedResponse.assertThat().field("label").is("modifier");
+
+ RestGenericFacetResponseModel creatorResponse = response.getContext().getFacets().get(1);
+ creatorResponse.assertThat().field("type").is("pivot");
+ creatorResponse.assertThat().field("label").is("creator");
+ }
+
+ @Test
+ public void searchWithRangePivoting()
+ {
+ SearchRequest query = createQuery("cars");
+
+ String endDate = LocalDateTime.now()
+ .format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'"));
+
+ Pagination pagination = new Pagination();
+ pagination.setMaxItems(2);
+ query.setPaging(pagination);
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("creator"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+
+ RestRequestRangesModel facetRangeModel = new RestRequestRangesModel();
+ facetRangeModel.setField("created");
+ facetRangeModel.setStart("2015-09-29T10:45:15.729Z");
+ facetRangeModel.setEnd(endDate);
+ facetRangeModel.setGap("+280DAY");
+ facetRangeModel.setLabel("aRange");
+ List ranges = new ArrayList<>();
+ ranges.add(facetRangeModel);
+ query.setRanges(ranges);
+
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel creatorpivot = new RestRequestPivotModel();
+ creatorpivot.setKey("creator");
+ RestRequestPivotModel rangepivot = new RestRequestPivotModel();
+ rangepivot.setKey("aRange");
+ creatorpivot.setPivots(Collections.singletonList(rangepivot));
+ pivotModelList.add(creatorpivot);
+ query.setPivots(pivotModelList);
+
+ SearchResponse response = query(query);
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().get(1);
+ facetResponseModel.assertThat().field("type").is("pivot");
+ facetResponseModel.assertThat().field("label").is("creator");
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().getFirst();
+ RestGenericFacetResponseModel rangeResponse = bucket.getFacets().getFirst();
+ rangeResponse.assertThat().field("type").is("range");
+ }
+
+ private void assertPivotResponse(SearchResponse response, String field, String alabel)
+ {
+ String label = alabel != null ? alabel : field;
+ response.getContext().assertThat().field("facetsFields").isNull();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().getFirst();
+ facetResponseModel.assertThat().field("type").is("pivot");
+ facetResponseModel.assertThat().field("label").is(label);
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().getFirst();
+ bucket.assertThat().field("label").isNotEmpty();
+ bucket.assertThat().field("filterQuery").is(field + ":\"" + bucket.getLabel() + "\"");
+ Assert.assertEquals(bucket.getMetrics().getFirst().getType(), "count");
+ Assert.assertTrue(bucket.getMetrics().getFirst().getValue().toString().contains("{count="));
+ }
+
+ @Test
+ public void searchWithPivotingUsingLabel()
+ {
+ SearchRequest query = createQuery("cars");
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ RestRequestFacetFieldModel creatorFacetFieldModel = new RestRequestFacetFieldModel("creator");
+ creatorFacetFieldModel.setLabel("create");
+ list.add(creatorFacetFieldModel);
+ RestRequestFacetFieldModel restRequestFacetFieldModel = new RestRequestFacetFieldModel("modifier");
+ restRequestFacetFieldModel.setLabel("aLabel");
+ list.add(restRequestFacetFieldModel);
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+ RestRequestPivotModel pivots = new RestRequestPivotModel();
+ pivots.setKey("create");
+ RestRequestPivotModel pivotmod = new RestRequestPivotModel();
+ pivotmod.setKey("aLabel");
+
+ List pivotModelList = new ArrayList<>();
+ pivotModelList.add(pivots);
+ pivotModelList.add(pivotmod);
+ query.setPivots(pivotModelList);
+ SearchResponse response = query(query);
+ assertPivotResponse(response, "creator", "create");
+
+ // Now check the nesting
+ RestGenericFacetResponseModel labelResponseModel = response.getContext().getFacets().get(1);
+ labelResponseModel.assertThat().field("type").is("pivot");
+ labelResponseModel.assertThat().field("label").isNotEmpty();
+ labelResponseModel.assertThat().field("label").is("aLabel");
+ RestGenericBucketModel bucket = labelResponseModel.getBuckets().getFirst();
+ bucket.assertThat().field("filterQuery").is("modifier:\"" + bucket.getLabel() + "\"");
+ Assert.assertEquals(bucket.getMetrics().getFirst().getType(), "count");
+ Assert.assertTrue(bucket.getMetrics().getFirst().getValue().toString().contains("{count="));
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAFTSInFieldTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAFTSInFieldTest.java
new file mode 100644
index 0000000000..c10a0f172e
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAFTSInFieldTest.java
@@ -0,0 +1,361 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 fieldNames = Stream.of("{http://www.alfresco.org/model/content/1.0}name",
+ "@{http://www.alfresco.org/model/content/1.0}name",
+ "cm_name",
+ "cm:name",
+ "@cm:name",
+ "name");
+
+ // For each field name, check that queries return consistent results with / out ''
+ fieldNames.forEach(fieldName -> {
+ // Query string without quotes
+ String query = fieldName + ":file.txt";
+
+ Set expectedNames = new HashSet<>();
+ expectedNames.add("file.txt"); // file1
+ expectedNames.add("1-file.txt"); // file2
+ expectedNames.add("file1.txt"); // file3
+ expectedNames.add("txt file"); // file4
+ expectedNames.add("file txt folder"); // folder1
+
+ testSearchQueryUnordered(query, expectedNames);
+
+ // Query string in single quotes
+ query = fieldName + ":'file.txt'";
+ testSearchQueryUnordered(query, expectedNames);
+ });
+ }
+
+ @Test(priority = 2)
+ public void testSearchInFieldTitle()
+ {
+ // Field names in various formats
+ Stream fieldNames = Stream.of("{http://www.alfresco.org/model/content/1.0}title",
+ "@{http://www.alfresco.org/model/content/1.0}title",
+ "cm_title",
+ "cm:title",
+ "@cm:title");
+
+ // For each field name, check that queries return consistent results with / out ''
+ fieldNames.forEach(fieldName -> {
+ String query = fieldName + ":" + file2.getName();
+ boolean fileFound = isContentInSearchResults(query, file2.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ testSearchQuery(query, 1);
+
+ query = fieldName + ":'" + file2.getName() + "\'";
+ fileFound = isContentInSearchResults(query, file2.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ testSearchQuery(query, 1);
+ });
+ }
+
+ @Test(priority = 3)
+ public void testSearchInFieldContent()
+ {
+ // Field names in various formats
+ List fieldNames = new ArrayList<>();
+ fieldNames.add("TEXT");
+ fieldNames.add("{http://www.alfresco.org/model/dictionary/1.0}content");
+ fieldNames.add("cm:content");
+ fieldNames.add("d:content");
+
+ // For each field name, check that queries return consistent results with / out ''
+ fieldNames.forEach(fieldName -> {
+ String query = fieldName + ":" + file3.getContent();
+ boolean fileFound = isContentInSearchResults(query, file3.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ Integer resultCount1 = testSearchQuery(query, null).getPagination().getTotalItems();
+
+ query = fieldName + ":'" + file3.getContent() + "\'";
+ fileFound = isContentInSearchResults(query, file3.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ testSearchQuery(query, resultCount1).getPagination().getTotalItems();
+ });
+ }
+
+ @Test
+ public void testSearchInFieldSITE()
+ {
+ String query = "SITE:" + testSite.getId();
+ boolean fileFound = isContentInSearchResults(query, folder1.getName(), true);
+ Assert.assertTrue(fileFound, "Site Not found for query: " + query);
+
+ Integer resultCount1 = testSearchQuery(query, 8, SearchLanguage.AFTS).getPagination().getTotalItems();
+
+ query = "SITE:'" + testSite.getId() + "\'";
+ fileFound = isContentInSearchResults(query, folder1.getName(), true);
+ Assert.assertTrue(fileFound, "Site Not found for query: " + query);
+
+ testSearchQuery(query, resultCount1, SearchLanguage.AFTS).getPagination().getTotalItems();
+ }
+
+ @Test(priority = 5)
+ public void testSearchInFieldTYPE()
+ {
+ // Field names in various formats
+ List fieldNames = new ArrayList<>();
+ fieldNames.add("TYPE");
+ fieldNames.add("EXACTTYPE");
+
+ // For each field name, check that queries return consistent results with / out ''
+ fieldNames.forEach(fieldName -> {
+
+ String query = fieldName + ":cm\\:content" + " and =cm:name:" + file1.getName();
+ boolean fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "Content Not found for query: " + query);
+
+ Integer resultCount1 = testSearchQuery(query, 1).getPagination().getTotalItems();
+
+ query = fieldName + ":'cm:content'" + " and =cm:name:" + file1.getName();
+ fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "Content Not found for query: " + query);
+
+ testSearchQuery(query, resultCount1).getPagination().getTotalItems();
+ });
+ }
+
+ @Test(priority = 6)
+ public void testSearchInFieldID()
+ {
+ String query = "ID:'workspace://SpacesStore/" + file1.getNodeRefWithoutVersion() + "'";
+ boolean fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "Content Not found for query: " + query);
+ testSearchQuery(query, 1).getPagination().getTotalItems();
+ }
+
+ @Test(priority = 7)
+ public void testSearchInFieldPARENT()
+ {
+ String query = "PARENT:" + folder1.getNodeRefWithoutVersion();
+
+ Set expectedNames = new HashSet<>();
+ expectedNames.add(file1.getName());
+ expectedNames.add(file2.getName());
+ expectedNames.add(file3.getName());
+ expectedNames.add(file4.getName());
+ expectedNames.add(file5.getName());
+
+ testSearchQueryUnordered(query, expectedNames);
+ query = "PARENT:'" + folder1.getNodeRefWithoutVersion() + "\'";
+ testSearchQueryUnordered(query, expectedNames);
+ }
+
+ @Test(priority = 8)
+ public void testSearchInFieldPRIMARYPARENT() throws EmptyRestModelCollectionException
+ {
+ // Create secondary association: file1 becomes a secondary child of folder2
+ RestNodeChildAssociationModel childAssoc1 = new RestNodeChildAssociationModel(file1.getNodeRefWithoutVersion(), "cm:contains");
+ restClient.authenticateUser(testUser).withCoreAPI().usingResource(folder2).addSecondaryChildren(childAssoc1);
+
+ RestNodeAssociationModelCollection secondaryChildren = restClient.authenticateUser(testUser).withCoreAPI().usingResource(folder2).getSecondaryChildren();
+ secondaryChildren.getEntryByIndex(0).assertThat().field("id").is(file1.getNodeRefWithoutVersion());
+
+ String query = "PRIMARYPARENT:'workspace://SpacesStore/" + folder1.getNodeRef() + "'";
+
+ Set expectedNames = new HashSet<>();
+ expectedNames.add(file1.getName());
+ expectedNames.add(file2.getName());
+ expectedNames.add(file3.getName());
+ expectedNames.add(file4.getName());
+ expectedNames.add(file5.getName());
+
+ testSearchQueryUnordered(query, expectedNames, SearchLanguage.AFTS);
+
+ query = "PARENT:'workspace://SpacesStore/" + folder2.getNodeRef() + "'";
+ boolean fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "Expected Content Not found for query: " + query);
+
+ testSearchQuery(query, 1, SearchLanguage.AFTS);
+ }
+
+ @Test(priority = 9)
+ public void testSearchInFieldNameExactMatch()
+ {
+ // Check that queries return consistent results with / out ''
+ String query = "=name:" + file1.getName();
+ boolean fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ Integer resultCount1 = testSearchQuery(query, 1).getPagination().getTotalItems();
+ Assert.assertSame(resultCount1, 1, "File count does not match for query: " + query);
+
+ query = "=name:'" + file1.getName() + "\'";
+ fileFound = isContentInSearchResults(query, file1.getName(), true);
+ Assert.assertTrue(fileFound, "File Not found for query: " + query);
+
+ testSearchQuery(query, resultCount1).getPagination().getTotalItems();
+ }
+
+ @Test(priority = 10)
+ public void testSearchInFieldNameQueryExpansion()
+ {
+ // Check that queries return consistent results with / out ''
+ String query = "~name:" + file1.getName();
+
+ Set expectedNames = new HashSet<>();
+ expectedNames.add(file1.getName());
+ expectedNames.add(file2.getName());
+ expectedNames.add(file3.getName());
+ expectedNames.add(file4.getName());
+ expectedNames.add(folder1.getName());
+
+ testSearchQueryUnordered(query, expectedNames);
+
+ query = "~name:'" + file1.getName() + "\'";
+ testSearchQueryUnordered(query, expectedNames);
+ }
+
+ @Test(priority = 11)
+ public void testWithConjunctionDisjunctionAndNegation()
+ {
+ // Query string to include Conjunction, Disjunction and Negation
+
+ String query1 = "~name:" + file1.getName(); // Query expected to return 5 results
+ String query2 = "=name:" + file2.getName(); // Query expected to return 1 result
+ String query3 = "=name:" + file3.getName(); // Query expected to return 1 result
+
+ // Check Query with Conjunction, Negation, Disjunction: returns right results
+ // "~name:file.txt and ! (=name:1-file.txt or =name:file1.txt)"
+ String query = query1 + " and ! (" + query2 + " or " + query3 + ")";
+
+ // Check that expected files are included in the results
+ Set expectedNames = new HashSet<>();
+ expectedNames.add("file.txt"); // file1
+ expectedNames.add("txt file"); // file4
+ expectedNames.add("file txt folder"); // folder1
+
+ SearchResponse response = testSearchQueryUnordered(query, expectedNames);
+
+ // Check result count is 5-(1+1)=3
+ int resultCount = response.getPagination().getTotalItems();
+ Assert.assertEquals(resultCount, 3, "File count does not match for query: " + query);
+
+ // Check that file2 and file3 are excluded from the results
+ boolean fileFound = isContentInSearchResponse(response, file2.getName());
+ Assert.assertFalse(fileFound, "File2 found for query: " + query);
+
+ fileFound = isContentInSearchResponse(response, file3.getName());
+ Assert.assertFalse(fileFound, "File3 found for query: " + query);
+ }
+
+ /** Check that a 501 error is returned when performing exact search on a tokenized field without cross-locale support. */
+ @Test(priority = 12)
+ public void testExactMatchWithoutCrossLocale()
+ {
+ // Force the query to hit Solr rather than the DB.
+ String query = "=cm:title:test and cm:name:*";
+ RestRequestQueryModel queryModel = new RestRequestQueryModel();
+ queryModel.setQuery(query);
+ SearchRequest searchRequest = new SearchRequest(queryModel);
+ restClient.authenticateUser(dataUser.getAdminUser()).withSearchAPI().search(searchRequest);
+ restClient.assertStatusCodeIs(HttpStatus.NOT_IMPLEMENTED);
+ }
+
+ /** Check that a 200 success is returned when performing exact search against the DB (even on a tokenized field without cross-locale support). */
+ @Test(priority = 13)
+ public void testExactMatchAgainstDB()
+ {
+ // Using a simple query we will hit the DB.
+ String query = "=cm:title:test";
+ RestRequestQueryModel queryModel = new RestRequestQueryModel();
+ queryModel.setQuery(query);
+ SearchRequest searchRequest = new SearchRequest(queryModel);
+ restClient.authenticateUser(dataUser.getAdminUser()).withSearchAPI().search(searchRequest);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAPATHTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAPATHTest.java
new file mode 100644
index 0000000000..e8a13db1a8
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAPATHTest.java
@@ -0,0 +1,163 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 buckets = getBuckets(response);
+ Assert.assertEquals(buckets.size(), 2);
+
+ buckets.forEach(bucket -> bucket.assertThat().field("label").contains("0/"));
+ }
+
+ /**
+ * Test to test that the facet buckets are returned correctly for sublevel 1/ Test to search for a searchString, that's unique to the test run and hence stable for any environment
+ */
+ @Test
+ public void searchLevel0andIncludeSubLevel1()
+ {
+ SearchRequest searchQuery = searchRequestWithAPATHFacet("name:" + unique_searchString, "1/");
+ SearchResponse response = query(searchQuery);
+
+ List buckets = getBuckets(response);
+ Assert.assertEquals(buckets.size(), 1, "Incorrect bucket count");
+
+ getFirstBucket(response).assertThat().field("label").contains("1/");
+ }
+
+ @Test
+ public void searchLevel2()
+ {
+ String queryString = "name:cars";
+
+ SearchRequest l1Request = searchRequestWithAPATHFacet(queryString, "1/");
+ SearchResponse l1Response = query(l1Request);
+
+ String l2Prefix = getFirstBucket(l1Response).getLabel().replaceFirst("^1/", "2/");
+
+ SearchRequest l2Request = searchRequestWithAPATHFacet(queryString, l2Prefix);
+ SearchResponse l2Response = query(l2Request);
+
+ FacetFieldBucket bucket = getFirstBucket(l2Response);
+ bucket.assertThat().field("label").contains(l2Prefix);
+
+ String l3Prefix = bucket.getLabel().replaceFirst("^2/", "3/");
+
+ SearchRequest l3Request = searchRequestWithAPATHFacet(queryString, l3Prefix);
+ SearchResponse l3response = query(l3Request);
+
+ List buckets = getBuckets(l3response);
+ Assert.assertEquals(buckets.size(), 1);
+
+ getFirstBucket(l3response).assertThat().field("label").contains(l3Prefix);
+ }
+
+ /**
+ * Creates a new {@link SearchRequest} for this test case.
+ *
+ * @param queryString
+ * the query string.
+ * @param facetPrefix
+ * the facet prefix.
+ * @return a new {@link SearchRequest} for this test case.
+ */
+ private SearchRequest searchRequestWithAPATHFacet(String queryString, String facetPrefix)
+ {
+ SearchRequest searchRequest = new SearchRequest();
+
+ RestRequestQueryModel query = new RestRequestQueryModel();
+ query.setQuery(queryString);
+ searchRequest.setQuery(query);
+
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ facetFields.setFacets(Collections.singletonList(new RestRequestFacetFieldModel("APATH", facetPrefix)));
+ searchRequest.setFacetFields(facetFields);
+
+ return searchRequest;
+ }
+
+ /**
+ * Extracts the first bucket from the given response.
+ *
+ * @param response
+ * the results of a query execution.
+ * @return the first bucket included in the search response.
+ */
+ private FacetFieldBucket getFirstBucket(SearchResponse response)
+ {
+ return getBuckets(response).iterator().next();
+ }
+
+ /**
+ * Extracts the buckets from the given response. The method also makes sure the buckets list is not empty in the input response.
+ *
+ * @param response
+ * the results of a query execution.
+ * @return the getBuckets included in the search response.
+ */
+ private List getBuckets(SearchResponse response)
+ {
+ List facetFields = response.getContext().getFacetsFields();
+ Assert.assertNotNull(facetFields);
+ Assert.assertFalse(facetFields.isEmpty());
+
+ List buckets = facetFields.iterator().next().getBuckets();
+ Assert.assertNotNull(buckets);
+ Assert.assertFalse(buckets.isEmpty());
+
+ return buckets;
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAspectTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAspectTest.java
new file mode 100644
index 0000000000..eff9277f6f
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchAspectTest.java
@@ -0,0 +1,178 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ * 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 properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:finance:Expense");
+ properties.put(PropertyIds.NAME, expenseLondon.getName());
+ properties.put(PropertyIds.SECONDARY_OBJECT_TYPE_IDS, List.of("P:finance:ParkEx"));
+ properties.put(financeLocationFieldName, "LondonBridge");
+ properties.put(parkingLocationFieldName, "LiverpoolStreet");
+
+ // Compose query
+ String queryFile = "cm:name:'" + expenseLondon.getName() + "'";
+ RestRequestQueryModel queryModel = new RestRequestQueryModel();
+ queryModel.setQuery(queryFile);
+ queryModel.setLanguage(SearchLanguage.AFTS.toString());
+ SearchRequest searchRequest = new SearchRequest();
+ searchRequest.setQuery(queryModel);
+ searchRequest.setInclude(List.of("aspectNames", "properties"));
+
+ cmisApi.authenticateUser(testUser)
+ .usingSite(testSite)
+ .usingResource(folder)
+ .createFile(expenseLondon, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ String parkingLocationQuery = parkingLocationFieldName + ":LiverpoolStreet";
+ Assert.assertTrue(waitForIndexing(parkingLocationQuery, true));
+
+ // check that the document found has the expected properties and aspects defined.
+ SearchResponse response = restClient.authenticateUser(testUser).withSearchAPI().search(searchRequest);
+ assertTrue(response.getEntries().getFirst().getModel().getAspectNames().contains("finance:ParkEx"),
+ "parkEx aspect was expected");
+ Map foundProperties = (Map) response.getEntries().getFirst().getModel().getProperties();
+ assertEquals(foundProperties.get(financeLocationFieldName), "LondonBridge",
+ "finance:Location property is expected to be defined with 'LondonBridge' as value");
+ assertEquals(foundProperties.get(parkingLocationFieldName), "LiverpoolStreet",
+ "finance:ParkingLocation property is expected to be defined with 'LiverpoolStreet' as value");
+
+ // remove aspect
+ Document doc = cmisApi.withCMISUtil().getCmisDocument(cmisApi.getLastResource());
+ List aspects = doc.getProperty(PropertyIds.SECONDARY_OBJECT_TYPE_IDS).getValues();
+ aspects.remove("P:finance:ParkEx");
+ Map updateProperties = new HashMap<>();
+ updateProperties.put(PropertyIds.SECONDARY_OBJECT_TYPE_IDS, aspects);
+
+ doc.updateProperties(updateProperties);
+
+ // Check that the field related to the removed aspect is no longer indexed for tested file
+ Assert.assertTrue(waitForIndexing(parkingLocationQuery, false));
+
+ response = restClient.authenticateUser(testUser).withSearchAPI().search(searchRequest);
+ assertFalse(response.getEntries().getFirst().getModel().getAspectNames().contains("finance:ParkEx"), "parkEx aspect was NOT expected");
+
+ // check that the document found has finance:Location property defined and finance:ParkingLocation has been removed
+ foundProperties = (Map) response.getEntries().getFirst().getModel().getProperties();
+ assertEquals(foundProperties.get(financeLocationFieldName), "LondonBridge",
+ "finance:Location property is expected to be defined with 'LondonBridge' as value");
+ assertNull(foundProperties.get(parkingLocationFieldName), "finance:ParkingLocation should not be included " +
+ "into the document anymore");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchCasesTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchCasesTest.java
new file mode 100644
index 0000000000..de1fd214f2
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchCasesTest.java
@@ -0,0 +1,251 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ * 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 facets = new ArrayList<>();
+ facets.add(new RestRequestFacetFieldModel("cm:content.mimetype"));
+ facets.add(new RestRequestFacetFieldModel("modifier"));
+ facetFields.setFacets(facets);
+ query.setFacetFields(facetFields);
+
+ SearchResponse response = query(query);
+
+ Assert.assertNotNull(response.getContext().getFacetsFields());
+ Assert.assertFalse(response.getContext().getFacetsFields().isEmpty());
+ Assert.assertNull(response.getContext().getFacetQueries());
+ Assert.assertNull(response.getContext().getFacets());
+
+ // Look up the "modifier" facet by label instead of relying on response ordering
+ RestResultBucketsModel modifierFacet = response.getContext().getFacetsFields().stream()
+ .filter(f -> "modifier".equals(f.getLabel()))
+ .findFirst()
+ .orElseThrow(() -> new AssertionError("'modifier' facet not found in response"));
+
+ modifierFacet.assertThat().field("label").is("modifier");
+ FacetFieldBucket bucket1 = modifierFacet.getBuckets().getFirst();
+ bucket1.assertThat().field("label").is(testUser.getUsername());
+ bucket1.assertThat().field("display").is("FN-" + testUser.getUsername() + " LN-" + testUser.getUsername());
+ bucket1.assertThat().field("filterQuery").is("modifier:\"" + testUser.getUsername() + "\"");
+ bucket1.assertThat().field("count").is(1);
+ }
+
+ @Test(priority = 15)
+ public void searchSpecialCharacters()
+ {
+ String specialCharfileName = "è¥äæ§ç§-åæ.pdf";
+ FileModel file = new FileModel(specialCharfileName, "è¥äæ§ç§-å欯¸" + "è¥äæ§ç§-å欯¸", "è¥äæ§ç§-å欯¸", FileType.TEXT_PLAIN,
+ "Text file with Special Characters: " + specialCharfileName);
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file);
+
+ waitForIndexing(file.getName(), true);
+
+ SearchRequest searchReq = createQuery("name:'" + specialCharfileName + "'");
+ SearchResponse nodes = query(searchReq);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ int searchCount = 0;
+ while (nodes.isEmpty() && searchCount < SEARCH_MAX_ATTEMPTS)
+ {
+ // Wait for the solr indexing (eventual consistency).
+ Utility.waitToLoopTime(properties.getSolrWaitTimeInSeconds(), "Wait For Results After Indexing. Retry Attempt: " + (searchCount + 1));
+ nodes = query(searchReq);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ searchCount++;
+ }
+
+ nodes.assertThat().entriesListIsNotEmpty();
+ restClient.onResponse().assertThat().body("list.entries.entry[0].name", Matchers.equalToIgnoringCase(specialCharfileName));
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchExactTermTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchExactTermTest.java
new file mode 100644
index 0000000000..b2f8dcb4f5
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchExactTermTest.java
@@ -0,0 +1,248 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 fields = new ArrayList<>();
+ fields.add(RestRequestFieldsModel.of("cm:content"));
+ highlight.setFields(fields);
+ SearchResponse nodes = query(queryReq, highlight);
+ nodes.assertThat().entriesListIsNotEmpty();
+ ResponseHighlightModel hl = nodes.getEntryByIndex(0).getSearch().getHighlight().getFirst();
+ assertTrue(hl.getSnippets().contains("The landrover discovery is not a sports ¿car?"));
+ }
+
+ @Test
+ public void searchNonIndexedData()
+ {
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:title");
+ queryReq.setUserQuery("zoro");
+
+ RestRequestHighlightModel highlight = new RestRequestHighlightModel();
+ highlight.setPrefix("¿");
+ highlight.setPostfix("?");
+ highlight.setMergeContiguous(true);
+ List fields = new ArrayList<>();
+ fields.add(RestRequestFieldsModel.of("cm:title"));
+ highlight.setFields(fields);
+ SearchResponse nodes = query(queryReq, highlight);
+ nodes.assertThat().entriesListDoesNotContain("highlight");
+ }
+
+ @Test
+ public void searchDataConjunctionGenericQuery()
+ {
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+
+ queryReq.setQuery("very AND name");
+
+ RestRequestHighlightModel highlight = new RestRequestHighlightModel();
+ highlight.setPrefix("¿");
+ highlight.setPostfix("?");
+ highlight.setMergeContiguous(false);
+ List fields = new ArrayList<>();
+ fields.add(RestRequestFieldsModel.of("cm:name"));
+ highlight.setFields(fields);
+ SearchResponse nodes = query(queryReq, highlight);
+ nodes.assertThat().entriesListDoesNotContain("highlight");
+
+ String expectedHighlight = "¿very? long ¿name?";
+
+ assertEquals(1, nodes.getEntries().size());
+
+ nodes.getEntries().stream()
+ .map(SearchNodeModel::getModel)
+ .map(SearchNodeModel::getSearch)
+ .map(SearchScoreModel::getHighlight).forEach((hl -> {
+ assertEquals(1, hl.size());
+ assertEquals(expectedHighlight, hl.getFirst().getSnippets().getFirst());
+ }));
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchNonIndexedFields.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchNonIndexedFields.java
new file mode 100644
index 0000000000..1ca9bde029
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchNonIndexedFields.java
@@ -0,0 +1,128 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:index:sample");
+ properties.put(PropertyIds.NAME, sampleFile.getName());
+ properties.put("index:indexed", "Indexed");
+ properties.put("index:nonIndexed", "Not indexed");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder).createFile(sampleFile, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ sampleFile = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "Sample");
+ sampleFile.setName("in2-" + sampleFile.getName());
+
+ // Only one field not indexed
+ properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:index:sample");
+ properties.put(PropertyIds.NAME, sampleFile.getName());
+ properties.put("index:nonIndexed", "Not indexed");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder).createFile(sampleFile, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ waitForIndexing(sampleFile.getName(), true);
+ }
+
+ /**
+ * Test that non indexed fields are not stored in SOLR Index
+ */
+ @Test(priority = 1)
+ public void testIndexedAndNonIndexedField()
+ {
+ SearchResponse response = queryAsUser(testUser, "index_indexed:[* TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "index_nonIndexed:[* TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 0);
+ }
+
+ /**
+ * Test that non indexed fields are not created in SOLR Schema
+ */
+ @Test(priority = 2)
+ public void testNonIndexedDoesNotExist()
+ {
+ RestAssured.basePath = "solr/alfresco";
+
+ restClient.configureSolrEndPoint();
+ restClient.configureRequestSpec().setBasePath(RestAssured.basePath);
+
+ RestRequest request = RestRequest.simpleRequest(HttpMethod.GET, "admin/luke");
+ RestTextResponse response = restClient.processTextResponse(request);
+ String bodyResponse = response.getResponse().getBody().print();
+
+ Assert.assertTrue(bodyResponse.contains("{http://www.alfresco.org/model/index/1.0}indexed"),
+ "Expecting index:indexed field to be present in SOLR Schema");
+ Assert.assertFalse(bodyResponse.contains("{http://www.alfresco.org/model/index/1.0}nonIndexed"),
+ "Expecting index:nonIndexed field NOT to be present in SOLR Schema");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchParentFieldTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchParentFieldTest.java
new file mode 100644
index 0000000000..6f7e47ce7d
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchParentFieldTest.java
@@ -0,0 +1,87 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ * 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 groups;
+
+ @BeforeClass(alwaysRun = true)
+ public void dataPreparation()
+ {
+ groups = new ArrayList<>();
+ groups.add(dataGroup.createRandomGroup());
+ groups.add(dataGroup.createRandomGroup());
+
+ dataGroup.addListOfUsersToGroup(groups.get(0), testUser);
+ dataGroup.addListOfUsersToGroup(groups.get(1), testUser);
+
+ waitForIndexing(
+ "TYPE:'cm:authorityContainer' AND cm:authorityName:'GROUP_" + groups.get(1).getGroupIdentifier() + "'",
+ true);
+ }
+
+ /**
+ * Test users in groups can be found using PARENT expressions.
+ */
+ @Test(priority = 1)
+ public void testSearchParentForPerson()
+ {
+ for (GroupModel group : groups)
+ {
+ // Find groupId to be used in the PARENT expression
+ String queryGroup = "TYPE:'cm:authorityContainer' AND cm:authorityName:'GROUP_" + group.getGroupIdentifier()
+ + "'";
+ SearchResponse response = queryAsUser(dataUser.getAdminUser(), queryGroup);
+ String groupId = response.getEntries().getFirst().getModel().getId();
+
+ // Find the user assigned as member of this group with PARENT clause
+ String queryParentGroup = "(TYPE:'cm:person' OR TYPE:'cm:authorityContainer') AND PARENT:'workspace://SpacesStore/"
+ + groupId + "'";
+
+ response = queryAsUser(dataUser.getAdminUser(), queryParentGroup);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1, "Expecting 1 user (" + testUser.getUsername()
+ + ") as member of this group (" + group.getGroupIdentifier() + ")");
+ }
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchPermissionsTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchPermissionsTest.java
new file mode 100644
index 0000000000..2e2265acea
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchPermissionsTest.java
@@ -0,0 +1,209 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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
+ * {
+ * "query": { "query": "cm:title:alfrezco", "language": "afts" },
+ * "spellcheck": { "query": "alfrezco" }
+ * }
+ *
+ */
+ @Test(priority = 2)
+ public void testSearchMissSpelledVersion2()
+ {
+ SearchRequest searchReq = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:title:alfrezco");
+ searchReq.setQuery(queryReq);
+
+ RestRequestSpellcheckModel spellCheck = new RestRequestSpellcheckModel();
+ spellCheck.setQuery("alfrezco");
+ searchReq.setSpellcheck(spellCheck);
+ assertResponse(query(searchReq));
+ }
+
+ @Test(priority = 3)
+ public void testSearchWithSpellcheckerAndCorrectSpelling()
+ {
+ SearchRequest searchReq = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("cm:title:alfresco");
+ queryReq.setUserQuery("alfresco");
+ searchReq.setQuery(queryReq);
+ searchReq.setSpellcheck(new RestRequestSpellcheckModel());
+ SearchResponse res = query(searchReq);
+ Assert.assertNull(res.getContext().getSpellCheck());
+ res.assertThat().entriesListIsNotEmpty();
+ }
+
+ /**
+ * Test to check the different spellcheck types {@code searchInsteadFor} and {@code didYouMean}. Suggestion ranking is based on maxEdits, count of entries, alphabetical order.
+ */
+ @Test(priority = 4)
+ public void testSpellCheckType()
+ {
+ // Create a file with the word in cm:name only
+ FileModel file = new FileModel("learning", "", "", FileType.TEXT_PLAIN, "");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file);
+
+ // Wait for the file to be indexed
+ Assert.assertTrue(waitForMetadataIndexing(file.getName(), true));
+
+ // Correct spelling with cm:name field
+ SearchResponse response = SearchSpellcheckQuery(testUser, "cm:name:learning", "learning");
+
+ response.assertThat().entriesListIsNotEmpty();
+ response.getContext().assertThat().field("spellCheck").isNull();
+
+ // Matching result, no spellcheck object returned
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Correct spelling with no specific field
+ response = SearchSpellcheckQuery(testUser, "learning", "learning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Correct spelling with a different field. Used cm:content field
+ response = SearchSpellcheckQuery(testUser, "cm:content:learning", "learning");
+
+ // 0 results, no spellcheck object returned
+ response.assertThat().entriesListIsEmpty();
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Incorrect spelling with cm:name field
+ response = SearchSpellcheckQuery(testUser, "cm:name:lerning", "lerning");
+
+ // 1 match with right spelling
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ // TODO: Investigate: Share shows searchInsteadFor = lerning, API shows learning
+ // testSearchSpellcheckResponse(response, "searchInsteadFor", "lerning");
+
+ // Incorrect spelling with no field
+ response = SearchSpellcheckQuery(testUser, "lerning", "lerning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ // TODO: Investigate: Share shows searchInsteadFor = lerning, API shows learning
+ // testSearchSpellcheckResponse(response, "searchInsteadFor", "lerning");
+
+ // Incorrect spelling with cm:content field
+ response = SearchSpellcheckQuery(testUser, "cm:content:lerning", "lerning");
+
+ // 0 results, no spellcheck object returned
+ response.assertThat().entriesListIsEmpty();
+ response.getContext().assertThat().field("spellCheck").isNull();
+
+ // Create a file with word with 1 max edit in cm:name only
+ FileModel file2 = new FileModel("leaning", "", "", FileType.TEXT_PLAIN, "");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file2);
+
+ // Create a file with word in cm:name and cm:content only
+ FileModel file3 = new FileModel("leaning 2", "", "", FileType.TEXT_PLAIN, "leaning 2");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file3);
+
+ Assert.assertTrue(waitForContentIndexing(file3.getContent(), true));
+
+ // Incorrect spelling with cm:name field
+ response = SearchSpellcheckQuery(testUser, "cm:name:lerning", "lerning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file3.getName()), "Expected file not returned in the search results: " + file3.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "leaning");
+
+ // Incorrect spelling with no field
+ response = SearchSpellcheckQuery(testUser, "lerning", "lerning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file3.getName()), "Expected file not returned in the search results: " + file3.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "leaning");
+
+ // Incorrect spelling with cm:content field
+ response = SearchSpellcheckQuery(testUser, "cm:content:lerning", "lerning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file3.getName()), "Expected file not returned in the search results: " + file3.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "leaning");
+
+ // Correct spelling with cm:name field
+ response = SearchSpellcheckQuery(testUser, "cm:name:learning", "learning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "didYouMean", "leaning");
+
+ // Correct spelling with no field
+ response = SearchSpellcheckQuery(testUser, "learning", "learning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "didYouMean", "leaning");
+
+ // Correct spelling with cm:content field
+ response = SearchSpellcheckQuery(testUser, "cm:content:learning", "learning");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file3.getName()), "Expected file not returned in the search results: " + file3.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "leaning");
+ }
+
+ /** Test for the spellcheck parameters minEdit and maxPrefix. */
+ @Test(priority = 5)
+ public void testSpellCheckParameters()
+ {
+ // Create a file with word in cm:name and cm:content
+ FileModel file = new FileModel("eklipse", "", "", FileType.TEXT_PLAIN, "eklipse");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file);
+
+ // Create a file with word in cm:name, cm:title and cm:content
+ FileModel file2 = new FileModel("eklipses", "eklipses", "", FileType.TEXT_PLAIN, "eklipses");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file2);
+
+ Assert.assertTrue(waitForContentIndexing(file2.getName(), true));
+
+ // Search with field not filled in either file
+ SearchResponse response = SearchSpellcheckQuery(testUser, "cm:description:'eclipse'", "eclipse");
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Incorrect spelling with the field on a file as well
+ response = SearchSpellcheckQuery(testUser, "cm:name:'eclipse'", "eclipse");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "eklipse");
+
+ // Incorrect spelling with no field for file1
+ response = SearchSpellcheckQuery(testUser, "eclipse", "eclipse");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "eklipse");
+
+ // Add Solr query, to check the suggestions on each shard
+ restClient.authenticateUser(testUser).withParams("spellcheck.q=eclipsess&spellcheck=on").withSolrAPI().getSelectQuery();
+
+ // Incorrect spelling with no field for file2
+ response = SearchSpellcheckQuery(testUser, "eclipsess", "eclipsess");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "eklipses");
+
+ // Search for the field only filled on file2 and not file1
+ response = SearchSpellcheckQuery(testUser, "cm:title:'eclipses'", "eclipses");
+
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "eklipses");
+
+ // Query using 3 edits (more than spellcheck works for [maxEdits<=2])
+ response = SearchSpellcheckQuery(testUser, "elapssed", "elapssed");
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Query with edit on first letter (does not work with spellcheck [minPrefix=1])
+ response = SearchSpellcheckQuery(testUser, "iklipse ", "iklipse ");
+ testSearchSpellcheckResponse(response, null, null);
+ }
+
+ /**
+ * Test to check the fields defined for spellcheck in shared.properties work (cm:name, cm:title, cm:description and cm:content).
+ */
+ @Test(priority = 6)
+ public void testSpellCheckFields()
+ {
+ // Create a file with same word in all fields
+ FileModel file = new FileModel("book", "book", "book", FileType.TEXT_PLAIN, "book");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file);
+
+ Assert.assertTrue(waitForContentIndexing(file.getContent(), true));
+
+ // Incorrect spelling with no field
+ SearchResponse response = SearchSpellcheckQuery(testUser, "bo0k", "bo0k");
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "book");
+
+ // Incorrect spelling with the cm:name field
+ response = SearchSpellcheckQuery(testUser, "cm:name:'bo0k'", "bo0k");
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "book");
+
+ // Incorrect spelling with the cm:title field
+ response = SearchSpellcheckQuery(testUser, "cm:title:'bo0k'", "bo0k");
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "book");
+
+ // Incorrect spelling with the cm:description field
+ response = SearchSpellcheckQuery(testUser, "cm:description:'bo0k'", "bo0k");
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "book");
+
+ // Incorrect spelling with the cm:content field
+ response = SearchSpellcheckQuery(testUser, "cm:content:'bo0k'", "bo0k");
+ Assert.assertTrue(isContentInSearchResponse(response, file.getName()), "Expected file not returned in the search results: " + file.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "book");
+
+ // Incorrect spelling with the cm:author field (not a suggestable field for spellcheck)
+ response = SearchSpellcheckQuery(testUser, "cm:author:'bo0k'", "bo0k");
+ testSearchSpellcheckResponse(response, null, null);
+ }
+
+ /** Test to check the ACL tracker works with spellcheck enabled. */
+ @Test(priority = 7)
+ public void testSpellCheckACL()
+ {
+ // Create User 2
+ testUser2 = dataUser.createRandomTestUser("User2");
+
+ // Create Private Site 2
+ testSite2 = new SiteModel(RandomData.getRandomName("Site2"));
+ testSite2.setVisibility(Visibility.PRIVATE);
+ testSite2 = dataSite.usingUser(testUser).createSite(testSite2);
+
+ // Make User 2 Site Collaborator
+ getDataUser().addUserToSite(testUser2, testSite2, UserRole.SiteCollaborator);
+
+ // Add file to testSite
+ FileModel file1 = new FileModel("spellcheckspacebar", "", "", FileType.TEXT_PLAIN, "spellcheckspacebar");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file1);
+
+ // Add file to testSite, testSite2
+ FileModel file2 = new FileModel("spellcheckspacecar", "", "", FileType.TEXT_PLAIN, "spellcheckspacecar");
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file2);
+ dataContent.usingUser(testUser).usingSite(testSite2).createContent(file2);
+
+ Assert.assertTrue(waitForContentIndexing(file2.getContent(), true));
+
+ // Checks for User 1
+ // Incorrect spelling with no field
+ SearchResponse response = SearchSpellcheckQuery(testUser, "spellcheckspaceber", "spellcheckspaceber");
+ Assert.assertTrue(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "spellcheckspacebar");
+
+ // Correct spelling with no field
+ response = SearchSpellcheckQuery(testUser, "spellcheckspacebar", "spellcheckspacebar");
+ Assert.assertTrue(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file1.getName());
+ testSearchSpellcheckResponse(response, "didYouMean", "spellcheckspacecar");
+
+ // Incorrect spelling with no field
+ response = SearchSpellcheckQuery(testUser, "spellcheckspacebra", "spellcheckspacebra");
+ Assert.assertTrue(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file1.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "spellcheckspacebar");
+
+ // Correct spelling with no field
+ response = SearchSpellcheckQuery(testUser, "spellcheckspacecar", "spellcheckspacecar");
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, null, null);
+
+ // Add Solr query, to check the suggestions on the shard
+ restClient.authenticateUser(testUser).withParams("spellcheck.q=spellcheckspacebur&spellcheck=on").withSolrAPI().getSelectQuery();
+
+ // Checks for User 2
+ // Incorrect spelling for files created with no field
+ response = SearchSpellcheckQuery(testUser2, "spellcheckspacebur", "spellcheckspacebur");
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "spellcheckspacecar");
+
+ // Correct spelling, no field
+ response = SearchSpellcheckQuery(testUser2, "spellcheckspacebar", "spellcheckspacebar");
+ Assert.assertFalse(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file1.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "spellcheckspacecar");
+
+ // Incorrect spelling, no field
+ response = SearchSpellcheckQuery(testUser2, "spellcheckspacecra", "spellcheckspacecra");
+ Assert.assertFalse(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file1.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, "searchInsteadFor", "spellcheckspacecar");
+
+ // Correct spelling, no field
+ response = SearchSpellcheckQuery(testUser2, "spellcheckspacecar", "spellcheckspacecar");
+ Assert.assertFalse(isContentInSearchResponse(response, file1.getName()), "Expected file not returned in the search results: " + file1.getName());
+ Assert.assertTrue(isContentInSearchResponse(response, file2.getName()), "Expected file not returned in the search results: " + file2.getName());
+ testSearchSpellcheckResponse(response, null, null);
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchTest.java
new file mode 100644
index 0000000000..c37915104c
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchTest.java
@@ -0,0 +1,307 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 expectedOrder = asList("alfresco.docx", "cars.PDF", "pangram.txt");
+
+ SearchRequest searchRequest = createQuery("cm_name:alfresco\\.docx cm_name:cars\\.PDF cm_name:pangram\\.txt");
+ searchRequest.addSortClause("FIELD", "name", true);
+
+ RestRequestFilterQueryModel filters = new RestRequestFilterQueryModel();
+ filters.setQuery("SITE:'" + testSite.getId() + "'");
+ searchRequest.setFilterQueries(filters);
+
+ SearchResponse responseWithAscendingOrder = query(searchRequest);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ assertEquals(
+ expectedOrder,
+ responseWithAscendingOrder.getEntries().stream()
+ .map(SearchNodeModel::getModel)
+ .map(SearchNodeModel::getName)
+ .collect(Collectors.toList()));
+
+ // Reverts the expected order...
+ reverse(expectedOrder);
+
+ // ...and test the descending order
+ searchRequest.getSort().clear();
+ searchRequest.addSortClause("FIELD", "name", false);
+
+ SearchResponse responseWithDescendingOrder = query(searchRequest);
+ assertEquals(
+ expectedOrder,
+ responseWithDescendingOrder.getEntries().stream()
+ .map(SearchNodeModel::getModel)
+ .map(SearchNodeModel::getName)
+ .collect(Collectors.toList()));
+ }
+
+ /**
+ * Tests the query execution with two sort clauses. The first clause has always the same value for all matches so the test makes sure the request is correctly processed and the returned order is determined by the second clause.
+ */
+ @Test
+ public void searchWithTwoSortClauses()
+ {
+ // Tests the ascending order first
+ List expectedOrder = asList("alfresco.docx", "cars.PDF", "pangram.txt");
+
+ SearchRequest searchRequest = createQuery("cm_name:alfresco\\.docx cm_name:cars\\.PDF cm_name:pangram\\.txt");
+ searchRequest.addSortClause("FIELD", "name", true);
+ searchRequest.addSortClause("FIELD", "creator", true);
+
+ RestRequestFilterQueryModel filters = new RestRequestFilterQueryModel();
+ filters.setQuery("SITE:'" + testSite.getId() + "'");
+ searchRequest.setFilterQueries(filters);
+
+ SearchResponse responseWithAscendingOrder = query(searchRequest);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ assertEquals(
+ expectedOrder,
+ responseWithAscendingOrder.getEntries().stream()
+ .map(SearchNodeModel::getModel)
+ .map(SearchNodeModel::getName)
+ .collect(Collectors.toList()));
+
+ // Reverts the expected order...
+ reverse(expectedOrder);
+
+ // ...and test the descending order
+ searchRequest.getSort().clear();
+ searchRequest.addSortClause("FIELD", "name", false);
+ searchRequest.addSortClause("FIELD", "creator", true);
+
+ SearchResponse responseWithDescendingOrder = query(searchRequest);
+ assertEquals(
+ expectedOrder,
+ responseWithDescendingOrder.getEntries().stream()
+ .map(SearchNodeModel::getModel)
+ .map(SearchNodeModel::getName)
+ .collect(Collectors.toList()));
+ }
+
+ @Test
+ public void searchQuery_includePermissions_shouldReturnNodeWithPermissionsInformation()
+ {
+ String query = "fox";
+ String include = "permissions";
+
+ SearchRequest retrievalQueryIncludingPermissionsInformation = createQuery(query);
+ retrievalQueryIncludingPermissionsInformation.setInclude(singletonList(include));
+
+ query(retrievalQueryIncludingPermissionsInformation);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ restClient.onResponse().assertThat().body("list.entries[0].entry.permissions", notNullValue());
+
+ SearchRequest retrievalQueryNotIncludingLockInformation = createQuery(query);
+
+ query(retrievalQueryNotIncludingLockInformation);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ restClient.onResponse().assertThat().body("list.entries[0].entry.permissions", nullValue());
+ }
+
+ @Test
+ public void searchQuery_includeIsLocked_shouldReturnNodeWithLockInformation()
+ {
+ String query = "fox";
+ String include = "isLocked";
+
+ SearchRequest retrievalQueryIncludingLockInformation = createQuery(query);
+ retrievalQueryIncludingLockInformation.setInclude(singletonList(include));
+
+ query(retrievalQueryIncludingLockInformation);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ restClient.onResponse().assertThat().body("list.entries[0].entry.isLocked", equalTo(false));
+
+ RestNodeLockBodyModel lockBodyModel = new RestNodeLockBodyModel();
+ lockBodyModel.setLifetime("EPHEMERAL");
+ lockBodyModel.setTimeToExpire(20);
+ lockBodyModel.setType("FULL");
+ restClient.authenticateUser(testUser).withCoreAPI().usingNode(file).lockNode(lockBodyModel);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ query(retrievalQueryIncludingLockInformation);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ restClient.onResponse().assertThat().body("list.entries[0].entry.isLocked", equalTo(true));
+
+ SearchRequest retrievalQueryNotIncludingLockInformation = createQuery(query);
+
+ query(retrievalQueryNotIncludingLockInformation);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ restClient.onResponse().assertThat().body("list.entries[0].entry.isLocked", nullValue());
+ }
+
+ @Test
+ public void searchQuery_includeInvalid_shouldReturnBadResponse()
+ {
+ String query = "fox";
+ String notValidInclude = "notValid";
+ SearchRequest permissionsRetrieval = createQuery(query);
+ permissionsRetrieval.setInclude(singletonList(notValidInclude));
+
+ query(permissionsRetrieval);
+
+ restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST);
+ restClient.onResponse()
+ .assertThat()
+ .body("error.briefSummary", containsString("An invalid argument was received " + notValidInclude));
+ }
+
+ // Test that when fields parameter is set, only restricted fields appear in the response
+ @Test
+ public void searchWithFields()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("alfresco");
+ query.setQuery(queryReq);
+
+ // Restrict to fields: parentId
+ List fields = new ArrayList<>();
+ fields.add("parentId");
+ query.setFields(fields);
+
+ query(query);
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ // Only Field parentId is included in the response
+ restClient.onResponse().assertThat().body("list.entries.entry[0].parentId", Matchers.notNullValue());
+ // Usual Fields such as 'name, id' aren't included in the response
+ restClient.onResponse().assertThat().body("list.entries.entry[0].name", Matchers.nullValue());
+ restClient.onResponse().assertThat().body("list.entries.entry[0].id", Matchers.nullValue());
+ }
+
+ @Test
+ public void searchSpecialCharacters()
+ {
+ // Create a file with Special Characters
+ String specialCharfileName = "è¥äæ§ç§-åæ.pdf";
+ FileModel file = new FileModel(specialCharfileName, "è¥äæ§ç§-å欯¸" + "è¥äæ§ç§-å欯¸", "è¥äæ§ç§-å欯¸", FileType.TEXT_PLAIN,
+ "Text file with Special Characters: " + specialCharfileName);
+ dataContent.usingUser(testUser).usingSite(testSite).createContent(file);
+
+ waitForIndexing(file.getName(), true);
+
+ // Search
+ SearchRequest searchReq = createQuery("name:'" + specialCharfileName + "'");
+ SearchResponse nodes = query(searchReq);
+
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ nodes.assertThat().entriesListIsNotEmpty();
+
+ restClient.onResponse().assertThat().body("list.entries.entry[0].name", Matchers.equalToIgnoringCase(specialCharfileName));
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchWithCustomModelTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchWithCustomModelTest.java
new file mode 100644
index 0000000000..53c8c01d0e
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SearchWithCustomModelTest.java
@@ -0,0 +1,243 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:finance:Expense");
+ properties.put(PropertyIds.NAME, expenseLondon.getName());
+ properties.put("finance:No", uniqueRef);
+ properties.put("finance:amount", 300);
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder).createFile(expenseLondon, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ // Location value is set to London
+ cmisApi.authenticateUser(testUser).usingResource(expenseLondon).addSecondaryTypes("P:finance:ParkEx").assertThat()
+ .secondaryTypeIsAvailable("P:finance:ParkEx");
+ cmisApi.authenticateUser(testUser).usingResource(expenseLondon).updateProperty("finance:ParkingLocation", "London");
+
+ FileModel expenseParis = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "Expense");
+ expenseParis.setName("fin2-" + expenseParis.getName());
+
+ properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:finance:Expense");
+ properties.put(PropertyIds.NAME, expenseParis.getName());
+ properties.put("finance:No", uniqueRef + 1);
+ properties.put("finance:amount", 100);
+ properties.put("finance:Title", "Airport Taxi Outgoing");
+ properties.put("finance:Emp", "David A");
+ properties.put("finance:Desc", "David's Taxi");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder).createFile(expenseParis, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ // Location value is set to Paris
+ cmisApi.authenticateUser(testUser).usingResource(expenseParis).addSecondaryTypes("P:finance:ParkEx").assertThat()
+ .secondaryTypeIsAvailable("P:finance:ParkEx");
+ cmisApi.authenticateUser(testUser).usingResource(expenseParis).updateProperty("finance:ParkingLocation", "Paris");
+
+ FileModel expenseNoLocation = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "receipt");
+ expenseNoLocation.setName("fin3-" + expenseNoLocation.getName());
+
+ properties = new HashMap<>();
+ properties.put(PropertyIds.OBJECT_TYPE_ID, "D:finance:Expense");
+ properties.put(PropertyIds.NAME, expenseNoLocation.getName());
+ properties.put("finance:No", uniqueRef + 2);
+ properties.put("finance:amount", 0);
+ properties.put("finance:Title", "Hotel Stay");
+ properties.put("finance:Emp", "Daniel S");
+ properties.put("finance:Desc", "Daniel's Taxi");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).usingResource(testFolder).createFile(expenseNoLocation, properties, VersioningState.MAJOR)
+ .assertThat().existsInRepo();
+
+ // Location value is set to null
+ cmisApi.authenticateUser(testUser).usingResource(expenseNoLocation).addSecondaryTypes("P:finance:ParkEx").assertThat()
+ .secondaryTypeIsAvailable("P:finance:ParkEx");
+
+ // Wait for the file to be indexed
+ waitForIndexing(expenseNoLocation.getName(), true);
+ }
+
+ // Search-1359: Search AFTS Query with Range
+ @Test(priority = 1)
+ public void testRangeQueryTextField()
+ {
+ // Search Range Query
+ SearchResponse response = queryAsUser(testUser, "finance_ParkingLocation:[* TO London]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+
+ // Content where Location = London is returned, If property is not set, its ignored.
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance_ParkingLocation:[London TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ // Content where Location = London, Paris is returned, If property is not set, its ignored.
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance_ParkingLocation:[London To Paris]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance_ParkingLocation:[* To *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+ }
+
+ @Test(priority = 2)
+ public void testRangeQueryTextFieldWhiteSpace()
+ {
+ SearchResponse response = queryAsUser(testUser, "finance:Emp:[* TO Daniel]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ // Tockenised field, so Returns Daniel, David A (A before Daniel)
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance:Emp:[Dan TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance:Emp:[Dan To David]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance:Emp:[* To *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+ }
+
+ @Test(priority = 3)
+ public void testRangeQueryTextFieldNonFacetable()
+ {
+ // Search Range Query
+ SearchResponse response = queryAsUser(testUser, "finance:Title:[* TO H]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance:Title:[Hotel TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ // Tockenised field, so Includes: Hotel, (Airport) Taxi Outgoing
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance:Title:[B To Hotel]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ // Tockenised field, so Includes: (Airport) Taxi Outgoing
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance:Title:[B To I]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance:Title:[* To *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+ }
+
+ @Test(priority = 4)
+ public void testRangeQueryTextFieldNotTockenised()
+ {
+ SearchResponse response = queryAsUser(testUser, "finance:Desc:[* TO David]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ // Includes: Daniel's Taxi
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance:Desc:[Dan TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance:Desc:[Dan To David]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 1);
+
+ response = queryAsUser(testUser, "finance:Desc:[* To *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+ }
+
+ @Test(priority = 5)
+ public void testRangeQueryDoubleField()
+ {
+ // Search Range Query
+ SearchResponse response = queryAsUser(testUser, "finance:amount:[* TO 100]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance_amount:[100 TO *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance_amount:[100 To 300]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 2);
+
+ response = queryAsUser(testUser, "finance_amount:[* To *]");
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ Assert.assertEquals(response.getPagination().getCount(), 3);
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ShardInfoTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ShardInfoTest.java
new file mode 100644
index 0000000000..5dd7ae6e74
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/ShardInfoTest.java
@@ -0,0 +1,245 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 stores = Arrays.asList("workspace://SpacesStore", "archive://SpacesStore");
+ List baseUrls = Arrays.asList("/solr/alfresco", "/solr/archive");
+
+ List entries = info.getEntries();
+ for (RestShardInfoModel shardInfoModel : entries)
+ {
+ RestShardInfoModel model = shardInfoModel.getModel();
+ assertEquals(model.getTemplate(), "rerank");
+ assertEquals(model.getMode(), "MASTER");
+ List shardingMethods = Arrays.asList("DB_ID", "DB_ID_RANGE", "EXPLICIT_ID", "ACL_ID", "MOD_ACL_ID", "DATE", "PROPERTY");
+ String shardingMethod = model.getShardMethod();
+ assertTrue(shardingMethods.contains(shardingMethod), "Unexpected Sharding Method Found: " + shardingMethod);
+ assertTrue(model.getHasContent());
+
+ assertTrue(stores.contains(model.getStores()));
+
+ List shards = model.getShards();
+ assertNotNull(shards);
+ RestShardModel shard = shards.iterator().next();
+ assertNotNull(shard);
+ List instances = shard.getInstances();
+ assertNotNull(instances);
+ RestInstanceModel instance = instances.iterator().next();
+ assertNotNull(instance);
+
+ assertTrue(baseUrls.contains(instance.getBaseUrl()));
+
+ // TODO: Ideally Solr Host and Port should be Parameterised
+ assertNotNull(instance.getHost(), "The solr host is not present");
+ assertEquals(instance.getPort().intValue(), 8983);
+ assertEquals(instance.getState(), "ACTIVE");
+ assertEquals(instance.getMode(), "MASTER");
+ }
+ }
+
+ /**
+ * Disabled: requires a CONFIG_Master_Slave deployment (a Solr master/slave * topology). The default CI environment runs a single SOLR node, so the * assertions on mode = "MIXED" cannot hold. Re-enable manually when running * against a master/slave configuration.
+ */
+ @Test(enabled = false)
+ public void getShardInfoWithAdminAuthorityMasterSlaveConfig() throws JsonProcessingException
+ {
+ RestShardInfoModelCollection info = restClient.authenticateUser(dataUser.getAdminUser()).withShardInfoAPI()
+ .getInfo();
+ skipIfShardInfoApiUnavailable();
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ info.assertThat().entriesListIsNotEmpty();
+ assertEquals(info.getPagination().getTotalItems().intValue(), 2);
+
+ List stores = Arrays.asList("workspace://SpacesStore", "archive://SpacesStore");
+ List baseUrls = Arrays.asList("/solr/alfresco", "/solr/archive");
+
+ List entries = info.getEntries();
+ for (RestShardInfoModel shardInfoModel : entries)
+ {
+ RestShardInfoModel model = shardInfoModel.getModel();
+ assertEquals(model.getTemplate(), "rerank");
+ assertEquals(model.getShardMethod(), "DB_ID");
+ assertEquals(model.getMode(), "MIXED");
+ assertTrue(model.getHasContent());
+
+ assertTrue(stores.contains(model.getStores()));
+
+ List shards = model.getShards();
+ assertNotNull(shards);
+ RestShardModel shard = shards.iterator().next();
+ assertNotNull(shard);
+ List instances = shard.getInstances();
+ assertNotNull(instances);
+ RestInstanceModel instance = instances.iterator().next();
+ assertNotNull(instance);
+
+ assertTrue(baseUrls.contains(instance.getBaseUrl()));
+
+ assertEquals(instance.getState(), "ACTIVE");
+ }
+ }
+
+ @Test
+ public void getShardInfoWithoutAdminAuthority() throws Exception
+ {
+ restClient.authenticateUser(dataUser.createRandomTestUser()).withShardInfoAPI().getInfo();
+ skipIfShardInfoApiUnavailable();
+ restClient.assertStatusCodeIs(HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+
+ /**
+ * This is a test to check that sharding is correctly working on bamboo and locally. Include test group 'sharding' on bamboo to enable this test to run
+ *
+ * @throws JsonProcessingException
+ * Disabled: requires a CONFIG_Sharding deployment with 2 or more shards. The default CI environment runs a single shard, so * {@code numberOfShards >= 2} cannot hold. Re-enable manually when running * against a sharded configuration.
+ */
+ @Test(enabled = false)
+ public void getShardInfoWith2OrMoreShards() throws JsonProcessingException
+ {
+ RestShardInfoModelCollection info = restClient.authenticateUser(dataUser.getAdminUser()).withShardInfoAPI().getInfo();
+ skipIfShardInfoApiUnavailable();
+ restClient.assertStatusCodeIs(HttpStatus.OK);
+ info.assertThat().entriesListIsNotEmpty();
+
+ assertEquals(info.getPagination().getTotalItems().intValue(), 2, "Pagination is: " + info.getPagination().getTotalItems().intValue() + " not expected value of 2");
+
+ // ... rest of method unchanged ...
+ Set stores = Sets.newHashSet("workspace://SpacesStore", "archive://SpacesStore");
+ List baseUrls = Arrays.asList("/solr/alfresco", "/solr/archive");
+ List entries = info.getEntries();
+
+ Set actualStores = entries.stream().map(shardInfoModel -> shardInfoModel.getModel().getStores()).collect(Collectors.toSet());
+ assertEquals(actualStores, stores, "The number of stores do not match the expected number of stores");
+
+ for (RestShardInfoModel shardInfoModel : entries)
+ {
+ RestShardInfoModel model = shardInfoModel.getModel();
+ assertEquals(model.getTemplate(), "rerank", "Template is not rerank, template found: " + model.getTemplate());
+ assertEquals(model.getMode(), "MASTER", "Mode is not MASTER, mode found: " + model.getMode());
+ assertTrue(model.getHasContent(), "There is no content on the shards");
+ assertTrue(model.getNumberOfShards() >= 2, "Number of shards is not equal to or greater than 2");
+
+ List shardingMethods = Arrays.asList("DB_ID", "DB_ID_RANGE", "EXPLICIT_ID", "ACL_ID", "MOD_ACL_ID", "DATE", "PROPERTY");
+ String shardingMethod = model.getShardMethod();
+ assertTrue(shardingMethods.contains(shardingMethod), "Unexpected Sharding Method Found: " + shardingMethod);
+
+ List shards = model.getShards();
+ assertNotNull(shards, "There are no shards present");
+ for (RestShardModel shardInstance : shards)
+ {
+ List instanceList = shardInstance.getInstances();
+ for (RestInstanceModel instanceX : instanceList)
+ {
+ assertTrue(baseUrls.contains(instanceX.getBaseUrl()), "The baseUrl is not present, baseUrl found is: " + instanceX.getBaseUrl());
+ assertEquals(instanceX.getState(), "ACTIVE", "Shard state is not ACTIVE, shard state is: " + instanceX.getState());
+ assertNotNull(instanceX.getPort(), "There is not port found for the instance");
+ assertEquals(instanceX.getMode(), "MASTER", "Mode is not MASTER, mode found: " + instanceX.getMode());
+ assertTrue(instanceX.getTransactionsRemaining() >= 0, "Transactions remaining is not more than 0, transactions remaining: " + instanceX.getTransactionsRemaining());
+ String shardParams = (instanceX).getShardParams();
+ switch (shardingMethod)
+ {
+ case "MOD_ACL_ID":
+ break;
+ case "ACL_ID":
+ break;
+ case "DB_ID":
+ break;
+ case "DB_ID_RANGE":
+ assertTrue(shardParams.contains("shard.range="), "Shard Parameters Not as expected for the Shard Method: DB_ID_RANGE");
+ break;
+ case "DATE":
+ assertTrue(shardParams.contains("shard.key="), "Shard Parameters Not as expected for the Shard Method: DATE");
+ assertTrue(shardParams.contains("shard.date.grouping="), "Shard Parameters Not as expected for the Shard Method: DATE");
+ break;
+ case "PROPERTY":
+ assertTrue(shardParams.contains("shard.key="), "Shard Parameters Not as expected for the Shard Method: PROPERTY");
+ assertTrue(shardParams.contains("shard.regex="), "Shard Parameters Not as expected for the Shard Method: PROPERTY");
+ break;
+ case "EXPLICIT_ID":
+ assertTrue(shardParams.contains("shard.key="), "Shard Parameters Not as expected for the Shard Method: EXPLICIT_ID");
+ break;
+ default:
+ throw new AssertionError("Shard Method Not expected: " + model.getShardMethod());
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SpecialCharacterSearchTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SpecialCharacterSearchTest.java
new file mode 100644
index 0000000000..57495bcd39
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/SpecialCharacterSearchTest.java
@@ -0,0 +1,50 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 statsModels = new ArrayList<>();
+ RestRequestStatsModel statsModel1 = new RestRequestStatsModel();
+ statsModels.add(statsModel1);
+ query.setStats(statsModels);
+ query.setPaging(pagination);
+
+ query(query);
+ restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
+ .containsSummary(String.format(RestErrorModel.MANDATORY_PARAM, "stats field"));
+
+ statsModel1.setField("DBID");
+ SearchResponse response = query(query);
+ // 8 metrics by default for a numeric field
+ Set metricTypes = assertStatsFacetedResponse(response, "DBID", 8);
+ assertTrue(metricTypes.containsAll(Arrays.asList("missing", "countValues", "sum", "min", "max", "sumOfSquares", "mean", "stddev")));
+
+ statsModel1.setField("creator");
+ response = query(query);
+ // 4 metrics by default for a string field
+ metricTypes = assertStatsFacetedResponse(response, "creator", 4);
+ assertTrue(metricTypes.containsAll(Arrays.asList("missing", "countValues", "min", "max")));
+
+ statsModel1.setField("modified");
+ response = query(query);
+ // 8 metrics by default for a date field
+ metricTypes = assertStatsFacetedResponse(response, "modified", 8);
+ assertTrue(metricTypes.containsAll(Arrays.asList("missing", "countValues", "sum", "min", "max", "sumOfSquares", "mean", "stddev")));
+
+ statsModel1.setField("modifier");
+ statsModel1.setMin(false);
+ statsModel1.setMax(false);
+ statsModel1.setMissing(false);
+ response = query(query);
+ metricTypes = assertStatsFacetedResponse(response, "modifier", 1);
+ assertFalse(metricTypes.containsAll(Arrays.asList("missing", "min", "max")));
+
+ statsModel1.setField("DBID");
+ statsModel1.setMin(true);
+ statsModel1.setMax(true);
+ statsModel1.setCountValues(false);
+ statsModel1.setMissing(false);
+ statsModel1.setSum(false);
+ statsModel1.setSumOfSquares(false);
+ statsModel1.setMean(false);
+ statsModel1.setStddev(false);
+ response = query(query);
+ metricTypes = assertStatsFacetedResponse(response, "DBID", 2);
+ assertTrue(metricTypes.containsAll(Arrays.asList("min", "max")));
+ assertFalse(metricTypes.containsAll(Arrays.asList("missing", "countValues", "sum", "sumOfSquares", "mean", "stddev")));
+
+ statsModel1.setField("modifier");
+ statsModel1.setMin(false);
+ statsModel1.setMax(false);
+ statsModel1.setCountDistinct(true);
+ statsModel1.setDistinctValues(true);
+ statsModel1.setCardinality(true);
+ response = query(query);
+ metricTypes = assertStatsFacetedResponse(response, "modifier", 3);
+ assertTrue(metricTypes.containsAll(Arrays.asList("countDistinct", "distinctValues", "cardinality")));
+
+ statsModel1.setField("DBID");
+ statsModel1.setPercentiles(Arrays.asList(1, 75, 99, 99.9));
+ statsModel1.setCountDistinct(false);
+ statsModel1.setDistinctValues(false);
+ statsModel1.setCardinality(false);
+ response = query(query);
+ assertStatsFacetedResponse(response, "DBID", 1);
+ RestGenericMetricModel percMetric = response.getContext().getFacets().getFirst().getBuckets().getFirst().getMetrics().get(0);
+ assertEquals(percMetric.getType(), "percentiles");
+ Map percVal = (Map) percMetric.getValue();
+ Map percentiles = (Map) percVal.get("percentiles");
+ assertEquals(percentiles.size(), 4);
+ assertTrue(percentiles.keySet().containsAll(Arrays.asList("1.0", "75.0", "99.0", "99.9")));
+ }
+
+ @Test
+ public void searchWithStatsLabel()
+ {
+ SearchRequest query = createQuery("cars");
+ Pagination pagination = new Pagination();
+ pagination.setMaxItems(2);
+ List statsModels = new ArrayList<>();
+ RestRequestStatsModel statsModel1 = new RestRequestStatsModel();
+ statsModel1.setField("modified");
+ statsModel1.setLabel("DateChanged");
+ statsModels.add(statsModel1);
+ query.setStats(statsModels);
+ query.setPaging(pagination);
+ SearchResponse response = query(query);
+ assertStatsFacetedResponse(response, "DateChanged", 8);
+ }
+
+ @Test
+ public void searchWithStatsFilters()
+ {
+ SearchRequest query = new SearchRequest();
+ RestRequestQueryModel queryReq = new RestRequestQueryModel();
+ queryReq.setQuery("content.mimetype:text/plain");
+ query.setQuery(queryReq);
+ List statsModels = new ArrayList<>();
+ RestRequestStatsModel statsModel1 = new RestRequestStatsModel();
+ statsModel1.setField("creator");
+ statsModel1.setMin(false);
+ statsModel1.setMax(false);
+ statsModel1.setMissing(false);
+ statsModels.add(statsModel1);
+ query.setFilterQueries(new RestRequestFilterQueryModel("cars", Collections.singletonList("justCars")));
+ query.setStats(statsModels);
+ SearchResponse response = query(query);
+ assertStatsFacetedResponse(response, "creator", 1);
+ RestGenericMetricModel countMetric = response.getContext().getFacets().get(0).getBuckets().get(0).getMetrics().get(0);
+ Integer count = response.getPagination().getTotalItems();
+ Map metricCount = (Map) countMetric.getValue();
+ assertEquals(count, metricCount.get("countValues"));
+
+ statsModel1.setExcludeFilters(Collections.singletonList("justCars"));
+ response = query(query);
+ assertStatsFacetedResponse(response, "creator", 1);
+ countMetric = response.getContext().getFacets().get(0).getBuckets().get(0).getMetrics().get(0);
+ count = response.getEntries().size();
+ metricCount = (Map) countMetric.getValue();
+ assertTrue((Integer) metricCount.get("countValues") > count, "With the exclude filter there will be more documents than returned");
+ }
+
+ @Test
+ public void searchWithStatsAndMutlilevelPivot()
+ {
+ SearchRequest query = createQuery("cars");
+
+ Pagination pagination = new Pagination();
+ pagination.setMaxItems(1);
+ query.setPaging(pagination);
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ RestRequestFacetFieldModel b0 = new RestRequestFacetFieldModel("SITE");
+ b0.setLabel("b0");
+ list.add(b0);
+ list.add(new RestRequestFacetFieldModel("created"));
+ RestRequestFacetFieldModel b2 = new RestRequestFacetFieldModel("modifier");
+ b2.setLabel("b2");
+ list.add(b2);
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel pivots = new RestRequestPivotModel();
+ pivots.setKey("b0");
+ RestRequestPivotModel pivotn = new RestRequestPivotModel();
+ pivotn.setKey("created");
+ RestRequestPivotModel pivot2 = new RestRequestPivotModel();
+ pivot2.setKey("aNumber");
+
+ pivotn.setPivots(Collections.singletonList(pivot2));
+ pivots.setPivots(Collections.singletonList(pivotn));
+ pivotModelList.add(pivots);
+ query.setPivots(pivotModelList);
+
+ List statsModels = new ArrayList<>();
+ RestRequestStatsModel statsModel1 = new RestRequestStatsModel();
+ statsModels.add(statsModel1);
+ query.setStats(statsModels);
+ statsModel1.setField("DBID");
+ statsModel1.setLabel("aNumber");
+
+ SearchResponse response = query(query);
+ response.getContext().assertThat().field("facetsFields").isNotNull();
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ assertEquals(response.getContext().getFacetsFields().size(), 1, "There should be 1 facet field for modifier");
+ assertEquals(response.getContext().getFacets().size(), 2, "There should be 1 pivot facet with stats on the end and a high level stats facet");
+
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().get(0);
+ facetResponseModel.assertThat().field("type").is("pivot");
+ facetResponseModel.assertThat().field("label").is("b0");
+
+ // pivot created
+ RestGenericFacetResponseModel created = facetResponseModel.getBuckets().get(0).getFacets().get(0);
+ created.assertThat().field("type").is("pivot");
+ created.assertThat().field("label").is("created");
+ // Another nested stats
+ assertEquals(created.getBuckets().get(0).getMetrics().size(), 9, "Metrics are on the end of a pivot bucket");
+ }
+
+ @Test
+ public void searchWithStatsAndPivot()
+ {
+ SearchRequest query = createQuery("cars");
+
+ Pagination pagination = new Pagination();
+ pagination.setMaxItems(2);
+ query.setPaging(pagination);
+ RestRequestFacetFieldsModel facetFields = new RestRequestFacetFieldsModel();
+ List list = new ArrayList<>();
+ list.add(new RestRequestFacetFieldModel("creator"));
+ facetFields.setFacets(list);
+ query.setFacetFields(facetFields);
+ query.setIncludeRequest(false);
+
+ SearchResponse response = query(query);
+ response.getContext().assertThat().field("facetsFields").isNotNull();
+
+ List pivotModelList = new ArrayList<>();
+ RestRequestPivotModel pivots = new RestRequestPivotModel();
+ pivots.setKey("creator");
+ RestRequestPivotModel pivotn = new RestRequestPivotModel();
+ pivotn.setKey("numericId");
+
+ pivots.setPivots(Collections.singletonList(pivotn));
+ pivotModelList.add(pivots);
+ query.setPivots(pivotModelList);
+
+ List statsModels = new ArrayList<>();
+ RestRequestStatsModel statsModel1 = new RestRequestStatsModel();
+ statsModels.add(statsModel1);
+ query.setStats(statsModels);
+ statsModel1.setField("DBID");
+ statsModel1.setLabel("numericId");
+
+ response = query(query);
+
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ assertEquals(response.getContext().getFacets().size(), 2, "There should be 1 pivot facet with stats on the end and a high level stats facet");
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().get(0);
+ facetResponseModel.assertThat().field("type").is("pivot");
+ facetResponseModel.assertThat().field("label").is("creator");
+ assertEquals(facetResponseModel.getBuckets().get(0).getMetrics().size(), 9, "Metrics are on the end of a pivot bucket");
+ RestGenericFacetResponseModel statsFacet = response.getContext().getFacets().get(1);
+ statsFacet.assertThat().field("type").is("stats");
+ statsFacet.assertThat().field("label").is("numericId");
+ }
+
+ private Set assertStatsFacetedResponse(SearchResponse response, String label, int metricsCount)
+ {
+ response.getContext().assertThat().field("facets").isNotEmpty();
+ RestGenericFacetResponseModel facetResponseModel = response.getContext().getFacets().get(0);
+ facetResponseModel.assertThat().field("type").is("stats");
+ // TODO : Change back to facetResponseModel.assertThat().field("label").is(label);
+ // when https://issues.alfresco.com/jira/browse/SEARCH-2125 is fixed
+ facetResponseModel.assertThat().field("label").contains(label);
+ RestGenericBucketModel bucket = facetResponseModel.getBuckets().get(0);
+ List metrics = bucket.getMetrics();
+ assertEquals(metrics.size(), metricsCount);
+ return metrics.stream().map(RestGenericMetricModel::getType).collect(Collectors.toSet());
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/crosslocale/SearchExactTermCrossLocaleTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/crosslocale/SearchExactTermCrossLocaleTest.java
new file mode 100644
index 0000000000..6c968a1818
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/crosslocale/SearchExactTermCrossLocaleTest.java
@@ -0,0 +1,299 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 expectedNames = newHashSet();
+ expectedNames.add(fileBanana.getName());
+ expectedNames.add(fileTaco.getName());
+ expectedNames.add(fileCat.getName());
+
+ testSearchQueryUnordered(fingerprintQuery, expectedNames, SearchLanguage.AFTS);
+ }
+
+ @Test(priority = 3)
+ public void searchSimilar()
+ {
+ String uuid = fileTaco.getNodeRefWithoutVersion();
+ Assert.assertNotNull(uuid);
+
+ // In the response entity there is a score of each doc, change below threshold to bring more like or less.
+ String fingerprintQuery = String.format("FINGERPRINT:%s_68", uuid);
+ SearchResponse response = query(fingerprintQuery);
+
+ int count = response.getEntries().size();
+ assertTrue(count >= 1);
+
+ Set expectedNames = newHashSet();
+ expectedNames.add(fileTaco.getName());
+
+ testSearchQueryUnordered(fingerprintQuery, expectedNames, SearchLanguage.AFTS);
+ }
+
+ @Test(priority = 4)
+ public void searchSimilar67Percent()
+ {
+ String uuid = fileTaco.getNodeRefWithoutVersion();
+ Assert.assertNotNull(uuid);
+
+ // Check that: When asked for less overlap of 67%: More documents are matched
+ String fingerprintQuery = String.format("FINGERPRINT:%s_67", uuid);
+ SearchResponse response = query(fingerprintQuery);
+
+ int count = response.getEntries().size();
+ assertTrue(count > 1);
+
+ Set expectedNames = newHashSet();
+ expectedNames.add(fileTaco.getName());
+ expectedNames.add(fileBanana.getName());
+ expectedNames.add(fileCat.getName());
+
+ testSearchQueryUnordered(fingerprintQuery, expectedNames, SearchLanguage.AFTS);
+ }
+
+ @Test(priority = 5)
+ @Bug(id = "SEARCH-2065")
+ public void searchAfterVersionUpdate()
+ {
+ // Check that fileToBeUpdated is found with a fingerprint query with fileOriginal: as they have similar content
+ boolean found = isContentInSearchResults("FINGERPRINT:" + fileOriginal.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), true);
+ Assert.assertTrue(found, "Matching File Not found in results for Fingerprint Query with original file");
+
+ // Update content of the fileToBeUpdated to match file1 in the dataprep
+ String newFileContent = "The quick brown fox jumps over the updated file";
+ fileToBeUpdated.setContent(newFileContent);
+ dataContent.usingUser(testUser).usingSite(testSite).usingResource(fileToBeUpdated).updateContent(newFileContent);
+
+ // Wair for the new version of the file to be indexed
+ assertTrue(waitForContentIndexing(fileToBeUpdated.getContent(), true));
+
+ // Check that fileToBeUpdated is NOT found with a fingerprint query with fileOriginal
+ boolean notFound = isContentInSearchResults("FINGERPRINT:" + fileOriginal.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), false);
+ Assert.assertTrue(notFound, "Updated File unexpectedly found in results for Fingerprint Query with original file");
+
+ // Check that fileToBeUpdated is found with a fingerprint query with file1
+ found = isContentInSearchResults("FINGERPRINT:" + fileBanana.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), true);
+ Assert.assertTrue(found, "Update File Not found in results for Fingerprint Query with updated content");
+ }
+
+ @Test(priority = 6)
+ @Bug(id = "SEARCH-2065")
+ public void searchAfterVersionRevert()
+ {
+ // Revert fileToBeUpdated to previous version
+ restClient.authenticateUser(testUser).withCoreAPI().usingNode(fileToBeUpdated).revertVersion("1.0", "{}");
+ String revertedContent = restClient.authenticateUser(testUser).withCoreAPI().usingNode(fileToBeUpdated).getVersionContent("1.2").getResponse().asString();
+ Assert.assertEquals(revertedContent, fileOriginal.getContent(), "Reverted content does not match Original");
+
+ // Wair for the new version of the file to be indexed
+ assertTrue(waitForContentIndexing(fileToBeUpdated.getContent(), true));
+
+ // Check that fileToBeUpdated is found with a fingerprint query with fileOriginal
+ boolean found = isContentInSearchResults("FINGERPRINT:" + fileOriginal.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), true);
+ Assert.assertTrue(found, "File not found in results for Fingerprint Query with original file after reverting version changes");
+
+ // Check that fileToBeUpdated is NOT found with a fingerprint query with file1
+ boolean notFound = isContentInSearchResults("FINGERPRINT:" + fileBanana.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), false);
+ Assert.assertTrue(notFound, "File appears in the results for Fingerprint Query even after reverting content changes");
+ }
+
+ @Test(priority = 7)
+ @Bug(id = "SEARCH-2065")
+ public void searchAfterVersionDelete()
+ {
+ // Revert fileToBeUpdated to previous version
+ restClient.authenticateUser(testUser).withCoreAPI().usingNode(fileToBeUpdated).deleteNodeVersion("1.2");
+
+ // Check that fileToBeUpdated is NOT found with a fingerprint query with fileOriginal
+ boolean notFound = isContentInSearchResults("FINGERPRINT:" + fileOriginal.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), false);
+ Assert.assertTrue(notFound, "Updated File unexpectedly found in results for Fingerprint Query with original file");
+
+ // Check that fileToBeUpdated is found with a fingerprint query with file1
+ boolean found = isContentInSearchResults("FINGERPRINT:" + fileBanana.getNodeRefWithoutVersion(), fileToBeUpdated.getName(), true);
+ Assert.assertTrue(found, "Update File Not found in results for Fingerprint Query with updated content");
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/tracker/CascadingIntegrationTest.java b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/tracker/CascadingIntegrationTest.java
new file mode 100644
index 0000000000..ce5f1552c8
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/java/org/alfresco/rest/search/tracker/CascadingIntegrationTest.java
@@ -0,0 +1,271 @@
+/*
+ * #%L
+ * Alfresco Search Services E2E Test
+ * %%
+ * Copyright (C) 2005 - 2026 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * 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 secondaryTypes = List.of("P:shard:sharding");
+ Map parentProperties = Map.of(PropertyIds.NAME, parentFolderSharded.getName(),
+ PropertyIds.OBJECT_TYPE_ID, "cmis:folder",
+ "cmis:secondaryObjectTypeIds", secondaryTypes,
+ "shard:shardId", "0");
+
+ // Create a first child in parent folder. It will be indexed in the parent shard (shard 0)
+ firstChildFileSharded = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "custom content");
+ Map propertiesFirstChild = Map.of(PropertyIds.NAME, firstChildFileSharded.getName(),
+ PropertyIds.OBJECT_TYPE_ID, "cmis:document",
+ "cmis:secondaryObjectTypeIds", secondaryTypes,
+ "shard:shardId", "0");
+
+ // Create a second child in parent folder. It will be indexed in shard 1.
+ secondChildFileSharded = FileModel.getRandomFileModel(FileType.TEXT_PLAIN, "custom content");
+ Map propertiesSecondChild = Map.of(PropertyIds.NAME, secondChildFileSharded.getName(),
+ PropertyIds.OBJECT_TYPE_ID, "cmis:document",
+ "cmis:secondaryObjectTypeIds", secondaryTypes,
+ "shard:shardId", "1");
+
+ cmisApi.authenticateUser(testUser).usingSite(testSite).createFolder(parentFolderSharded, parentProperties).then()
+ .usingResource(parentFolderSharded)
+ .createFile(firstChildFileSharded, propertiesFirstChild, VersioningState.MAJOR)
+ .createFile(secondChildFileSharded, propertiesSecondChild, VersioningState.MAJOR);
+
+ // Check everything is indexed
+ assertTrue(waitForIndexing(firstChildFileSharded.getName(), true), "file: " + firstChildFileSharded.getName() + " has not been indexed.");
+ assertTrue(waitForIndexing(secondChildFileSharded.getName(), true), "file: " + secondChildFileSharded.getName() + " has not been indexed.");
+ assertTrue(waitForIndexing(parentFolderSharded.getName(), true), "file: " + parentFolderSharded.getName() + " has not been indexed.");
+
+ // Query to find nodes where Path with original folder name matches
+ String parentQuery = "PATH:\"/app:company_home/st:sites/cm:" + testSite.getTitle() +
+ "/cm:documentLibrary/cm:" + parentFolderSharded.getName() + "/*\"";
+
+ // Rename parent folder
+ String parentNewName = "parentRenamedSharding";
+ parentFolderSharded.setName(parentNewName);
+ ContentModel parentNewNameModel = new ContentModel(parentNewName);
+ dataContent.usingUser(testUser).usingResource(parentFolderSharded).renameContent(parentNewNameModel);
+
+ String parentQueryAfterRename = "PATH:\"/app:company_home/st:sites/cm:" + testSite.getTitle() +
+ "/cm:documentLibrary/cm:" + parentNewName + "/*\"";
+
+ // Query using new parent name: Expect the two children
+ int descendantCountOfNewNameBeforeUpdate = query(parentQueryAfterRename).getPagination().getCount();
+ Assert.assertEquals(descendantCountOfNewNameBeforeUpdate, 0, "There should be 0 results performing the new query before updating parent name");
+
+ assertTrue(waitForMetadataIndexing(parentNewName, true), "failing while renaming " + parentFolderSharded.getName() + " to " + parentNewName);
+
+ boolean indexingInProgress = !isContentInSearchResults(parentQueryAfterRename, firstChildFileSharded.getName(), true);
+
+ // Query using new parent name: Expect the two children
+ int descendantCountOfNewName = query(parentQueryAfterRename).getPagination().getCount();
+ Assert.assertEquals(descendantCountOfNewName, 2, String.format("Indexing in progress: %s New renamed path has not the same descendants as before renaming: %s", indexingInProgress, parentQuery));
+
+ // Query using old parent name: Expect no descendant after rename
+ int descendantCountOfOriginalName = query(parentQuery).getPagination().getCount();
+ Assert.assertEquals(descendantCountOfOriginalName, 0, "Old path still has descendants: " + parentQuery);
+
+ }
+}
diff --git a/packaging/tests/tas-restapi/src/test/resources/default.properties b/packaging/tests/tas-restapi/src/test/resources/default.properties
index 60d58a5b73..52a243dee8 100644
--- a/packaging/tests/tas-restapi/src/test/resources/default.properties
+++ b/packaging/tests/tas-restapi/src/test/resources/default.properties
@@ -8,10 +8,12 @@ sync.scheme=http
sync.server=localhost
sync.port=9090
-# Solr Server Settings
+# Solr Server Settings.
solr.scheme=http
solr.server=localhost
solr.port=8083
+solr.secret=secret
+solr.secret.name=X-Alfresco-Search-Secret
#Solr Indexing Time
solrWaitTimeInSeconds=20
@@ -20,6 +22,16 @@ solrWaitTimeInSeconds=20
admin.user=admin
admin.password=admin
+# CMIS settings - required by search E2E tests
+cmis.binding=browser
+cmis.basePath=/alfresco/api/-default-/public/cmis/versions/1.1/${cmis.binding}
+
+# ActiveMQ - required by TAS dataprep
+messaging.broker.url=failover:(tcp://localhost:61616)?timeout=3000
+messaging.broker.ssl=false
+messaging.broker.username=admin
+messaging.broker.password=admin
+
# Identity Service configuration
# set this property to run tests using AIS
# identity-service.auth-server-url=http://localhost:8999/auth
diff --git a/packaging/tests/tas-restapi/src/test/resources/elasticsearch-e2e-suite.xml b/packaging/tests/tas-restapi/src/test/resources/elasticsearch-e2e-suite.xml
new file mode 100644
index 0000000000..fc5b30c26b
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/elasticsearch-e2e-suite.xml
@@ -0,0 +1,138 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/finance-model.xml b/packaging/tests/tas-restapi/src/test/resources/finance-model.xml
new file mode 100644
index 0000000000..67799651d2
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/finance-model.xml
@@ -0,0 +1,149 @@
+
+
+ Administrator
+
+
+
+
+
+
+ Receipt
+ cm:content
+
+
+ ReceiptValue
+ d:double
+ false
+
+ false
+ true
+
+
+
+ ReceiptNo
+ d:long
+ false
+
+ true
+
+
+
+
+
+ Expense
+ cm:content
+
+
+ No
+ d:long
+ false
+
+ true
+ true
+
+
+
+ Emp
+ d:text
+ false
+
+ true
+ true
+
+
+
+ Amount
+ d:double
+ false
+
+ true
+ true
+
+
+
+ Title
+ d:text
+ false
+
+ both
+ false
+
+
+
+ Description
+ d:text
+ false
+
+ false
+ false
+
+
+
+ CreatedAt
+ d:datetime
+ false
+
+ true
+
+
+
+ Location
+ d:text
+ true
+
+ true
+ true
+
+
+
+ EmpNo
+ d:int
+ false
+
+ true
+ true
+
+
+
+ EmpDept
+ d:float
+ false
+
+ true
+ true
+
+
+
+
+
+
+
+ Parking Expense
+
+
+ Location
+ d:text
+ true
+
+ true
+ true
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/indexing-disabled-content-model.xml b/packaging/tests/tas-restapi/src/test/resources/indexing-disabled-content-model.xml
new file mode 100644
index 0000000000..3cabaf650d
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/indexing-disabled-content-model.xml
@@ -0,0 +1,32 @@
+
+
+ Indexing Disabled Content Model for Non-Indexed Fields E2E Tests
+ Alfresco
+
+
+
+
+
+
+ Sample
+ cm:content
+
+
+ Indexed Field
+ d:text
+ false
+ true
+
+ Non-Indexed Field
+ d:text
+ false
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/search-2139-model.xml b/packaging/tests/tas-restapi/src/test/resources/search-2139-model.xml
new file mode 100644
index 0000000000..a19aa3334c
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/search-2139-model.xml
@@ -0,0 +1,74 @@
+
+
+ All Field Types Model for Search Field Definition Tests (SEARCH-2139)
+ Alfresco
+
+
+
+
+
+
+ All Field Types Text Aspect
+
+
+ Text LOV Partial
+ d:text
+ false
+ true
+
+ Text Pattern Unique
+ d:text
+ false
+ true
+
+ Text Free
+ d:text
+ false
+ true
+
+ Text Pattern Many
+ d:text
+ false
+ true
+
+ Text LOV Whole (not tokenised)
+ d:text
+ false
+ false
+
+ MLText LOV Partial
+ d:mltext
+ false
+ true
+
+ MLText Free
+ d:mltext
+ false
+ true
+
+ MLText LOV Whole (not tokenised)
+ d:mltext
+ false
+ false
+
+ Multiple MLText
+ d:mltext
+ false
+ true
+ true
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/search-e2e-crosslocale-suite.xml b/packaging/tests/tas-restapi/src/test/resources/search-e2e-crosslocale-suite.xml
new file mode 100644
index 0000000000..4398da08b6
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/search-e2e-crosslocale-suite.xml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/sharding-content-model.xml b/packaging/tests/tas-restapi/src/test/resources/sharding-content-model.xml
new file mode 100644
index 0000000000..0cc8091979
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/sharding-content-model.xml
@@ -0,0 +1,27 @@
+
+
+ Sharding Content Model for Explicit Routing E2E Tests
+ Alfresco
+
+
+
+
+
+
+ Sharding
+
+
+ Shard ID
+ d:text
+ false
+
+ false
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-fingerprint-suite.xml b/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-fingerprint-suite.xml
new file mode 100644
index 0000000000..feca9c20ac
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-fingerprint-suite.xml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-spellcheck-suite.xml b/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-spellcheck-suite.xml
new file mode 100644
index 0000000000..d0757c0bdf
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/solr-search-e2e-spellcheck-suite.xml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/packaging/tests/tas-restapi/src/test/resources/test-suites/part2-suite.xml b/packaging/tests/tas-restapi/src/test/resources/test-suites/part2-suite.xml
index de3460385f..14e5417245 100644
--- a/packaging/tests/tas-restapi/src/test/resources/test-suites/part2-suite.xml
+++ b/packaging/tests/tas-restapi/src/test/resources/test-suites/part2-suite.xml
@@ -15,7 +15,15 @@
+
diff --git a/packaging/tests/tas-restapi/src/test/resources/tokenised-model.xml b/packaging/tests/tas-restapi/src/test/resources/tokenised-model.xml
new file mode 100644
index 0000000000..5c351f0eb2
--- /dev/null
+++ b/packaging/tests/tas-restapi/src/test/resources/tokenised-model.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+ cm:content
+
+
+ d:text
+
+ true
+
+
+
+ d:text
+
+ false
+
+
+
+ d:text
+
+ both
+
+
+
+
+
+
\ No newline at end of file
diff --git a/repository/src/test/resources/search/model/finance-model.xml b/repository/src/test/resources/search/model/finance-model.xml
new file mode 100644
index 0000000000..67799651d2
--- /dev/null
+++ b/repository/src/test/resources/search/model/finance-model.xml
@@ -0,0 +1,149 @@
+
+
+ Administrator
+
+
+
+
+
+
+ Receipt
+ cm:content
+
+
+ ReceiptValue
+ d:double
+ false
+
+ false
+ true
+
+
+
+ ReceiptNo
+ d:long
+ false
+
+ true
+
+
+
+
+
+ Expense
+ cm:content
+
+
+ No
+ d:long
+ false
+
+ true
+ true
+
+
+
+ Emp
+ d:text
+ false
+
+ true
+ true
+
+
+
+ Amount
+ d:double
+ false
+
+ true
+ true
+
+
+
+ Title
+ d:text
+ false
+
+ both
+ false
+
+
+
+ Description
+ d:text
+ false
+
+ false
+ false
+
+
+
+ CreatedAt
+ d:datetime
+ false
+
+ true
+
+
+
+ Location
+ d:text
+ true
+
+ true
+ true
+
+
+
+ EmpNo
+ d:int
+ false
+
+ true
+ true
+
+
+
+ EmpDept
+ d:float
+ false
+
+ true
+ true
+
+
+
+
+
+
+
+ Parking Expense
+
+
+ Location
+ d:text
+ true
+
+ true
+ true
+
+
+
+
+
+
\ No newline at end of file
diff --git a/scripts/ci/build.sh b/scripts/ci/build.sh
index 6b25a69374..da87a457b7 100644
--- a/scripts/ci/build.sh
+++ b/scripts/ci/build.sh
@@ -14,6 +14,10 @@ else
PROFILES="-Pags"
fi
+if [[ "${REQUIRES_TAS_TESTS}" == "true" ]]; then
+ PROFILES="${PROFILES} -Pall-tas-tests"
+fi
+
if [[ "${REQUIRES_INSTALLED_ARTIFACTS}" == "true" ]]; then
PHASE="install"
else