View Javadoc
1   package de.dlr.shepard.integrationtests;
2   
3   import static io.restassured.RestAssured.given;
4   import static org.assertj.core.api.Assertions.assertThat;
5   import static org.junit.jupiter.api.Assertions.assertTrue;
6   
7   import de.dlr.shepard.common.search.io.CollectionSearchBody;
8   import de.dlr.shepard.common.search.io.CollectionSearchParams;
9   import de.dlr.shepard.common.search.io.CollectionSearchResult;
10  import de.dlr.shepard.common.util.Constants;
11  import de.dlr.shepard.context.collection.io.CollectionIO;
12  import io.quarkus.test.junit.QuarkusIntegrationTest;
13  import io.restassured.specification.RequestSpecification;
14  import java.util.ArrayList;
15  import java.util.List;
16  import java.util.Map;
17  import java.util.UUID;
18  import org.junit.jupiter.api.Test;
19  
20  @QuarkusIntegrationTest
21  public class PaginatedCollectionSearcherIT extends BaseTestCaseIT {
22  
23    private static final String searchURL = "/" + Constants.SEARCH + "/" + Constants.COLLECTIONS;
24  
25    private CollectionSearchResult searchCollections(RequestSpecification spec, CollectionSearchBody body, String url) {
26      return given()
27        .spec(spec)
28        .body(body)
29        .when()
30        .post(url)
31        .then()
32        .statusCode(200)
33        .extract()
34        .as(CollectionSearchResult.class);
35    }
36  
37    @Test
38    public void paginatedCollectionSearcher_findCollectionByName_success() {
39      // Arrange
40      UUID runId = UUID.randomUUID();
41      String query = "{\"property\": \"name\", \"value\": \"" + runId + "\", \"operator\": \"contains\"}";
42      CollectionSearchParams params = new CollectionSearchParams(query);
43      CollectionSearchBody searchBody = new CollectionSearchBody(params);
44      CollectionIO collection1 = createCollection(runId + " firstCollection");
45  
46      // Act
47      CollectionSearchResult result = searchCollections(requestSpecOfDefaultUser, searchBody, searchURL);
48  
49      // Assert
50      assertThat(result.getResults()).anyMatch(res -> res.getId().equals(collection1.getId()));
51      assertThat(result.getTotalResults()).isEqualTo(1);
52      assertThat(result.getSearchParams()).isEqualTo(params);
53    }
54  
55    @Test
56    public void paginatedCollectionSearcher_findCollectionById_success() {
57      // Arrange
58      CollectionIO collection2 = createCollection("collection2");
59      String query = "{\"property\": \"id\", \"value\": " + collection2.getId().toString() + ", \"operator\": \"eq\"}";
60      CollectionSearchParams params = new CollectionSearchParams(query);
61      CollectionSearchBody searchBody = new CollectionSearchBody(params);
62  
63      // Act
64      CollectionSearchResult result = searchCollections(requestSpecOfDefaultUser, searchBody, searchURL);
65  
66      // Assert
67      assertThat(result.getResults()).anyMatch(res -> res.getId().equals(collection2.getId()));
68      assertThat(result.getTotalResults()).isEqualTo(1);
69      assertThat(result.getSearchParams()).isEqualTo(params);
70    }
71  
72    @Test
73    public void paginatedCollectionSearcher_findCompletePageByName_success() {
74      // Arrange
75      UUID runId = UUID.randomUUID();
76      int pageSize = 5;
77      String searchURL = "/" + Constants.SEARCH + "/" + Constants.COLLECTIONS + "?page=0&size=" + pageSize;
78      String query =
79        "{\"property\": \"name\", \"value\": \"" +
80        runId +
81        "testCollectionSearchWithPaginationSize\", \"operator\": \"contains\"}";
82      CollectionSearchParams params = new CollectionSearchParams(query);
83      CollectionSearchBody searchBody = new CollectionSearchBody(params);
84      int numberOfCollections = 6;
85      for (int i = 0; i < numberOfCollections; i++) {
86        CollectionIO col = createCollection(runId + "testCollectionSearchWithPaginationSize" + i);
87        col.setDescription("I have been updated.");
88        given()
89          .spec(requestSpecOfDefaultUser)
90          .body(col)
91          .when()
92          .put("/" + Constants.COLLECTIONS + "/" + col.getId())
93          .then()
94          .statusCode(200)
95          .extract()
96          .as(CollectionIO.class);
97      }
98  
99      // Act
100     CollectionSearchResult result = searchCollections(requestSpecOfDefaultUser, searchBody, searchURL);
101 
102     // Assert
103     assertThat(result.getResults().size()).isEqualTo(pageSize);
104     assertThat(result.getTotalResults()).isEqualTo(numberOfCollections);
105     assertThat(result.getSearchParams()).isEqualTo(params);
106   }
107 
108   @Test
109   public void paginatedCollectionSearcher_findCompleteAndOrderedPageByName_success() {
110     // Arrange
111     UUID runId = UUID.randomUUID();
112     int pageSize = 20;
113     String searchURL =
114       "/" +
115       Constants.SEARCH +
116       "/" +
117       Constants.COLLECTIONS +
118       "?page=0&size=" +
119       pageSize +
120       "&orderBy=updatedAt&orderDesc=false";
121     String query =
122       "{\"property\": \"name\", \"value\": \"" +
123       runId +
124       "testCollectionSearchWithPaginationSize\", \"operator\": \"contains\"}";
125     CollectionSearchParams params = new CollectionSearchParams(query);
126     CollectionSearchBody searchBody = new CollectionSearchBody(params);
127     int numberOfCollections = 21;
128     List<CollectionIO> createdCollections = new ArrayList<CollectionIO>();
129     for (int i = 0; i < numberOfCollections; i++) {
130       CollectionIO col = createCollection(runId + "testCollectionSearchWithPaginationSize" + i);
131       createdCollections.add(col);
132     }
133     CollectionIO collectionToUpdate = createdCollections.get(0);
134     collectionToUpdate.setDescription("I have been updated.");
135     given()
136       .spec(requestSpecOfDefaultUser)
137       .body(collectionToUpdate)
138       .when()
139       .put("/" + Constants.COLLECTIONS + "/" + collectionToUpdate.getId())
140       .then()
141       .statusCode(200)
142       .extract()
143       .as(CollectionIO.class);
144 
145     // Act
146     CollectionSearchResult result = searchCollections(requestSpecOfDefaultUser, searchBody, searchURL);
147 
148     // Assert
149     assertThat(result.getResults().size()).isEqualTo(pageSize);
150     assertThat(result.getTotalResults()).isEqualTo(numberOfCollections);
151     assertThat(result.getSearchParams()).isEqualTo(params);
152   }
153 
154   @Test
155   public void paginatedCollectionSearcher_searchForPrivateCollection_collectionOnlyReturnedForOwner() {
156     // Arrange
157     UUID runId = UUID.randomUUID();
158     given()
159       .spec(requestSpecOfOtherUser)
160       .body(Map.of("name", runId.toString()))
161       .when()
162       .post("/" + Constants.COLLECTIONS)
163       .then()
164       .statusCode(201)
165       .extract()
166       .as(CollectionIO.class);
167     String query = "{\"property\": \"name\", \"value\": \"" + runId + "\", \"operator\": \"contains\"}";
168     CollectionSearchParams params = new CollectionSearchParams(query);
169     CollectionSearchBody searchBody = new CollectionSearchBody(params);
170 
171     // Act
172     CollectionSearchResult resultForUserOne = searchCollections(requestSpecOfDefaultUser, searchBody, searchURL);
173     CollectionSearchResult resultForOtherUser = searchCollections(requestSpecOfOtherUser, searchBody, searchURL);
174 
175     // Assert
176     assertThat(resultForUserOne.getResults().size()).isEqualTo(0);
177     assertThat(resultForUserOne.getSearchParams()).isEqualTo(params);
178     assertThat(resultForUserOne.getTotalResults()).isEqualTo(0);
179     assertThat(resultForOtherUser.getResults().size()).isEqualTo(1);
180     assertThat(resultForOtherUser.getSearchParams()).isEqualTo(params);
181     assertThat(resultForOtherUser.getTotalResults()).isEqualTo(1);
182   }
183 
184   @Test
185   public void paginatedCollectionSearcher_openLastPage_pageContainsCollections() {
186     // Arrange
187     String query = "{\"property\": \"name\", \"value\": \"\", \"operator\": \"contains\"}";
188     CollectionSearchParams params = new CollectionSearchParams(query);
189     CollectionSearchBody searchBody = new CollectionSearchBody(params);
190 
191     int pageSize = 20;
192     int totalCollections = searchCollections(
193       requestSpecOfDefaultUser,
194       searchBody,
195       searchURL + "?page=0&size=" + pageSize
196     ).getTotalResults();
197     int lastPage = Math.floorDiv(totalCollections, pageSize);
198     int numberOfItemsOnLastPage = totalCollections % pageSize;
199 
200     // Act
201     CollectionSearchResult resultsOfLastPage = searchCollections(
202       requestSpecOfDefaultUser,
203       searchBody,
204       searchURL + "?page=" + lastPage + "&size=" + pageSize
205     );
206 
207     // Assert
208     assertThat(resultsOfLastPage.getResults().size()).isEqualTo(numberOfItemsOnLastPage);
209   }
210 
211   @Test
212   public void paginatedCollectionSearcher_sortByName_orderedResults() {
213     // Arrange
214     UUID runId = UUID.randomUUID();
215     String query = "{\"property\": \"name\", \"value\": \"" + runId + "\", \"operator\": \"contains\"}";
216     CollectionSearchParams params = new CollectionSearchParams(query);
217     CollectionSearchBody searchBody = new CollectionSearchBody(params);
218 
219     int numberOfCollections = 3;
220     for (int i = 0; i < numberOfCollections; i++) {
221       createCollection(i + " " + runId + "sortByName");
222     }
223 
224     // Act
225     CollectionSearchResult resultsSortedByNameDescending = searchCollections(
226       requestSpecOfDefaultUser,
227       searchBody,
228       searchURL + "?page=0&size=20&orderBy=name&orderDesc=true"
229     );
230     CollectionSearchResult resultsSortedByNameAscending = searchCollections(
231       requestSpecOfDefaultUser,
232       searchBody,
233       searchURL + "?page=0&size=20&orderBy=name&orderDesc=false"
234     );
235 
236     // Assert
237     assertThat(resultsSortedByNameDescending.getResults().size()).isEqualTo(numberOfCollections);
238     assertTrue(resultsSortedByNameDescending.getResults().get(0).getName().startsWith("2"));
239     assertTrue(resultsSortedByNameDescending.getResults().get(2).getName().startsWith("0"));
240     assertThat(resultsSortedByNameAscending.getResults().size()).isEqualTo(numberOfCollections);
241     assertTrue(resultsSortedByNameAscending.getResults().get(0).getName().startsWith("0"));
242     assertTrue(resultsSortedByNameAscending.getResults().get(2).getName().startsWith("2"));
243   }
244 }