2 * ============LICENSE_START===================================================
3 * SPARKY (AAI UI service)
4 * ============================================================================
5 * Copyright © 2017 AT&T Intellectual Property.
6 * Copyright © 2017 Amdocs
8 * ============================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 * ============LICENSE_END=====================================================
22 * ECOMP and OpenECOMP are trademarks
23 * and service marks of AT&T Intellectual Property.
26 package org.onap.aai.sparky.search;
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertNotNull;
30 import static org.junit.Assert.assertNull;
32 import java.io.IOException;
33 import java.util.ArrayList;
34 import java.util.List;
36 import javax.servlet.http.HttpServletRequest;
38 import org.apache.camel.CamelContext;
39 import org.apache.camel.Exchange;
40 import org.apache.camel.Message;
41 import org.apache.camel.impl.DefaultCamelContext;
42 import org.apache.camel.impl.DefaultExchange;
43 import org.json.JSONObject;
44 import org.junit.Before;
45 import org.junit.Test;
46 import org.mockito.Mockito;
47 import org.onap.aai.sparky.common.search.CommonSearchSuggestion;
48 import org.onap.aai.sparky.search.api.SearchProvider;
49 import org.onap.aai.sparky.search.entity.MockSearchResponse;
50 import org.onap.aai.sparky.search.entity.QuerySearchEntity;
51 import org.onap.aai.sparky.search.entity.SearchSuggestion;
52 import org.onap.aai.sparky.search.registry.SearchProviderRegistry;
53 import org.onap.aai.sparky.util.HttpServletHelper;
55 import com.fasterxml.jackson.databind.ObjectMapper;
58 public class UnifiedSearchProcessorTest {
60 public interface Suggester {
61 public void addSuggestion( SearchSuggestion suggestion );
64 private abstract class AbstractDummySearchProvider implements SearchProvider, Suggester {
66 protected List<SearchSuggestion> suggestions;
68 protected AbstractDummySearchProvider() {
69 suggestions = new ArrayList<SearchSuggestion>();
72 public List<SearchSuggestion> getSuggestions() {
77 public List<SearchSuggestion> search(QuerySearchEntity queryRequest) {
78 return getSuggestions();
82 private class AlphaSearchProvider extends AbstractDummySearchProvider {
83 public AlphaSearchProvider() {
88 public void addSuggestion(SearchSuggestion suggestion) {
89 if (suggestion != null) {
90 suggestions.add(suggestion);
95 private class BravoSearchProvider extends AbstractDummySearchProvider {
96 public BravoSearchProvider() {
101 public void addSuggestion(SearchSuggestion suggestion) {
102 if (suggestion != null) {
103 suggestions.add(suggestion);
108 private class GammaSearchProvider extends AbstractDummySearchProvider {
109 public GammaSearchProvider() {
114 public void addSuggestion(SearchSuggestion suggestion) {
115 if (suggestion != null) {
116 suggestions.add(suggestion);
121 private SearchServiceAdapter mockSearchAdapter;
123 private UnifiedSearchProcessor unifiedSearchProcessor;
124 private Message mockRequestMessage;
125 private ObjectMapper mapper;
127 private Exchange exchange;
128 private CamelContext camelContext;
133 camelContext = new DefaultCamelContext();
134 exchange = new DefaultExchange(camelContext);
136 mockRequestMessage = Mockito.mock(Message.class);
137 exchange.setIn(mockRequestMessage);
139 unifiedSearchProcessor = new UnifiedSearchProcessor();
140 unifiedSearchProcessor.setUseOrderedSearchProviderKeys(true);
142 mapper = new ObjectMapper();
144 mockSearchAdapter = Mockito.mock(SearchServiceAdapter.class);
149 public void validateDefaultConstructor() {
151 // initially it should be null until the bean wiring initializes it
152 assertNull(unifiedSearchProcessor.getSearchProviderRegistry());
158 public void validateAccessors() {
160 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
161 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
163 // initially it should be null until the bean wiring initializes it
164 assertNotNull(unifiedSearchProcessor.getSearchProviderRegistry());
165 assertEquals(0, searchProviderRegistry.getSearchProviders().size());
169 private void initializeSearchMocks(String requestPayload) {
171 HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
172 HttpServletHelper.setRequestPayload(request, "application/json", requestPayload);
174 Mockito.when(request.getRequestURI()).thenReturn("fakeUri");
175 Mockito.when(request.getLocalPort()).thenReturn(8001);
176 Mockito.when(mockRequestMessage.getBody(Mockito.eq(HttpServletRequest.class))).thenReturn(request);
177 Mockito.when(mockRequestMessage.getBody(Mockito.eq(String.class))).thenReturn(requestPayload);
181 private String getSearchRequestJson(String queryString, int maxResults) {
183 JSONObject root = new JSONObject();
184 root.put("queryStr", queryString);
185 root.put("maxResults", maxResults);
187 return root.toString();
191 private String getExternalSearchRequestJson() {
192 JSONObject root = new JSONObject();
194 root.put("view", "testView");
195 root.put("entityId", "thisIsAnId");
196 root.put("entityType", "pserver");
198 return root.toString();
203 public void testSearch_search_when_noSearchProviders() throws IOException {
207 initializeSearchMocks(getSearchRequestJson("vnfs",10));
209 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
210 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
213 unifiedSearchProcessor.search(exchange);
215 assertEquals(200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE));
217 String entityPayload = exchange.getOut().getBody(String.class);
218 assertNotNull(entityPayload);
220 MockSearchResponse searchResponse = mapper.readValue(entityPayload, MockSearchResponse.class);
222 assertEquals(0, searchResponse.getTotalFound());
223 assertEquals(0, searchResponse.getSuggestions().size());
228 public void testSearch_search_when_ThreeSearchProviders_no_suggestions() throws IOException {
232 initializeSearchMocks(getSearchRequestJson("vnfs",10));
234 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
236 AlphaSearchProvider alpha = new AlphaSearchProvider();
237 BravoSearchProvider bravo = new BravoSearchProvider();
238 GammaSearchProvider gamma = new GammaSearchProvider();
240 searchProviderRegistry.addSearchProvider(alpha);
241 searchProviderRegistry.addSearchProvider(bravo);
242 searchProviderRegistry.addSearchProvider(gamma);
244 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
247 unifiedSearchProcessor.search(exchange);
249 assertEquals(200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE));
251 String entityPayload = exchange.getOut().getBody(String.class);
252 assertNotNull(entityPayload);
255 * With a null view name, an empty filter set should be returned - there should be 0 filters
258 SearchResponse searchResponse = mapper.readValue(entityPayload, SearchResponse.class);
260 assertEquals(0, searchResponse.getTotalFound());
261 assertEquals(0, searchResponse.getSuggestions().size());
265 private void addSuggestions(int numSuggestions, String suggestionPrefix, Suggester suggester) {
266 for ( int x = 0; x < numSuggestions; x++ ){
267 CommonSearchSuggestion suggestion = new CommonSearchSuggestion();
268 suggestion.setText(suggestionPrefix + "-" + x);
269 suggester.addSuggestion(suggestion);
273 private int countSuggestions(String suggestionPrefix, SearchResponse response) {
277 for ( SearchSuggestion suggestion : response.getSuggestions()) {
279 if ( suggestion.getText() != null && suggestion.getText().startsWith(suggestionPrefix)) {
288 private int countSuggestions(String suggestionPrefix, MockSearchResponse response) {
292 for ( SearchSuggestion suggestion : response.getSuggestions()) {
294 if ( suggestion.getText() != null && suggestion.getText().startsWith(suggestionPrefix)) {
305 public void testSearch_search_when_ThreeSearchProviders_5suggestions_each() throws IOException {
309 initializeSearchMocks(getSearchRequestJson("vnfs",10));
311 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
313 AlphaSearchProvider alpha = new AlphaSearchProvider();
314 BravoSearchProvider bravo = new BravoSearchProvider();
315 GammaSearchProvider gamma = new GammaSearchProvider();
317 addSuggestions(5, "alpha", alpha);
318 addSuggestions(5, "bravo", bravo);
319 addSuggestions(5, "gamma", gamma);
321 searchProviderRegistry.addSearchProvider(alpha);
322 searchProviderRegistry.addSearchProvider(bravo);
323 searchProviderRegistry.addSearchProvider(gamma);
325 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
328 unifiedSearchProcessor.search(exchange);
330 assertEquals(200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE));
332 String entityPayload = exchange.getOut().getBody(String.class);
333 assertNotNull(entityPayload);
335 MockSearchResponse searchResponse = mapper.readValue(entityPayload, MockSearchResponse.class);
337 assertEquals(10, searchResponse.getTotalFound());
338 assertEquals(10, searchResponse.getSuggestions().size());
340 assertEquals( 4, countSuggestions("alpha", searchResponse));
341 assertEquals( 3, countSuggestions("bravo", searchResponse));
342 assertEquals( 3, countSuggestions("gamma", searchResponse));
347 public void testSearch_search_when_ThreeSearchProviders_mixedNumSuggestions() throws IOException {
351 initializeSearchMocks(getSearchRequestJson("vnfs",13));
353 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
355 AlphaSearchProvider alpha = new AlphaSearchProvider();
356 BravoSearchProvider bravo = new BravoSearchProvider();
357 GammaSearchProvider gamma = new GammaSearchProvider();
359 searchProviderRegistry.addSearchProvider(alpha);
360 searchProviderRegistry.addSearchProvider(bravo);
361 searchProviderRegistry.addSearchProvider(gamma);
363 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
365 addSuggestions(45,"alpha",alpha);
366 addSuggestions(1,"bravo",bravo);
367 addSuggestions(99,"gamma",gamma);
370 unifiedSearchProcessor.search(exchange);
372 assertEquals(200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE));
374 String entityPayload = exchange.getOut().getBody(String.class);
375 assertNotNull(entityPayload);
377 MockSearchResponse searchResponse = mapper.readValue(entityPayload, MockSearchResponse.class);
379 assertEquals(13, searchResponse.getTotalFound());
380 assertEquals(13, searchResponse.getSuggestions().size());
383 * There should be an even divide of suggestions per search provider relative
384 * to the suggestions available per search provider.
385 * Alpha has 45 suggestions
386 * Bravo has 1 suggestion
387 * Gamma has 99 suggestions
389 * We only asked for 13 suggestions to be returned, so based on the suggestion
390 * distribution algorithm we will get a fair distribution of suggestions per provider
391 * relative to what each provider has available. Resulting in:
398 assertEquals( 6, countSuggestions("alpha", searchResponse));
399 assertEquals( 1, countSuggestions("bravo", searchResponse));
400 assertEquals( 6, countSuggestions("gamma", searchResponse));
405 public void testSearch_search_when_ThreeSearchProviders_wantedMoreSuggestionsThanAvailable() throws IOException {
409 initializeSearchMocks(getSearchRequestJson("vnfs",13));
411 SearchProviderRegistry searchProviderRegistry = new SearchProviderRegistry();
413 AlphaSearchProvider alpha = new AlphaSearchProvider();
414 BravoSearchProvider bravo = new BravoSearchProvider();
415 GammaSearchProvider gamma = new GammaSearchProvider();
417 searchProviderRegistry.addSearchProvider(alpha);
418 searchProviderRegistry.addSearchProvider(bravo);
419 searchProviderRegistry.addSearchProvider(gamma);
421 unifiedSearchProcessor.setSearchProviderRegistry(searchProviderRegistry);
423 addSuggestions(1,"alpha",alpha);
424 addSuggestions(4,"bravo",bravo);
425 addSuggestions(0,"gamma",gamma);
428 unifiedSearchProcessor.search(exchange);
430 assertEquals(200, exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE));
432 String entityPayload = exchange.getOut().getBody(String.class);
433 assertNotNull(entityPayload);
435 MockSearchResponse searchResponse = mapper.readValue(entityPayload, MockSearchResponse.class);
437 assertEquals(5, searchResponse.getTotalFound());
438 assertEquals(5, searchResponse.getSuggestions().size());
440 assertEquals( 1, countSuggestions("alpha", searchResponse));
441 assertEquals( 4, countSuggestions("bravo", searchResponse));
442 assertEquals( 0, countSuggestions("gamma", searchResponse));