sdnr/wt/common/src/test/java/org/onap/ccsdk/features/sdnr/wt/common/test/TestDbQueries.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2019 highstreet technologies GmbH Intellectual Property.
   6  * All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  */
  22 package org.onap.ccsdk.features.sdnr.wt.common.test;
  23
  24 import static org.junit.Assert.fail;
  25
  26 import org.json.JSONException;
  27 import org.junit.Test;
  28 import org.onap.ccsdk.features.sdnr.wt.common.database.data.DbFilter;
  29 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.BoolQueryBuilder;
  30 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.QueryBuilder;
  31 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.QueryBuilders;
  32 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.SortOrder;
  33 import org.onap.ccsdk.features.sdnr.wt.common.test.JSONAssert;
  34
  35
  36 public class TestDbQueries {
  37
  38         private static final String MATCH_ALL_QUERY = "{\n" +
  39                         "    \"query\": {\n" +
  40                         "        \"match_all\" : {\n" +
  41                         "        }\n" +
  42                         "    }\n" +
  43                         "}";
  44         private static final String MATCH_QUERY_KEY = "is-required";
  45         private static final Object MATCH_QUERY_VALUE = true;
  46         private static final String MATCH_QUERY = "{\n" +
  47                         "    \"query\": {\n" +
  48                         "        \"match\" : {\n" +
  49                         "            \""+MATCH_QUERY_KEY+"\" : "+MATCH_QUERY_VALUE+"\n" +
  50                         "        }\n" +
  51                         "    }\n" +
  52                         "}";
  53         private static final String MATCH_QUERY_KEY2 = "node-id";
  54         private static final Object MATCH_QUERY_VALUE2 = "sim2";
  55         private static final String BOOL_QUERY_MUST = "{\n" +
  56                         "    \"query\": {\n" +
  57                         "        \"bool\": {\n" +
  58                         "            \"must\": [\n" +
  59                         "                {\n" +
  60                         "                    \"match\": {\n" +
  61                         "                        \""+MATCH_QUERY_KEY+"\": "+MATCH_QUERY_VALUE+"\n" +
  62                         "                    }\n" +
  63                         "                },\n" +
  64                         "                {\n" +
  65                         "                    \"match\": {\n" +
  66                         "                        \""+MATCH_QUERY_KEY2+"\":"+MATCH_QUERY_VALUE2+" \n" +
  67                         "                    }\n" +
  68                         "                }\n" +
  69                         "            ]\n" +
  70                         "        }\n" +
  71                         "    }\n" +
  72                         "}";
  73         private static final String BOOL_QUERY_MUST_SINGLE = "{\n" +
  74                                         "    \"query\": {\n" +
  75                                         "        \"bool\": {\n" +
  76                                         "            \"must\": {\n" +
  77                                         "                    \"match\": {\n" +
  78                                         "                        \""+MATCH_QUERY_KEY+"\": "+MATCH_QUERY_VALUE+"\n" +
  79                                         "                    }\n" +
  80                                         "                }\n" +
  81                                         "        }\n" +
  82                                         "    }\n" +
  83                                         "}";
  84         private static final String BOOL_QUERY_SHOULD = "{\n" +
  85                         "    \"query\": {\n" +
  86                         "        \"bool\": {\n" +
  87                         "            \"should\": [\n" +
  88                         "                {\n" +
  89                         "                    \"match\": {\n" +
  90                         "                        \""+MATCH_QUERY_KEY+"\": "+MATCH_QUERY_VALUE+"\n" +
  91                         "                    }\n" +
  92                         "                },\n" +
  93                         "                {\n" +
  94                         "                    \"match\": {\n" +
  95                         "                        \""+MATCH_QUERY_KEY2+"\":"+MATCH_QUERY_VALUE2+" \n" +
  96                         "                    }\n" +
  97                         "                }\n" +
  98                         "            ]\n" +
  99                         "        }\n" +
 100                         "    }\n" +
 101                         "}";
 102         private static final String BOOL_QUERY_SHOULD_SINGLE = "{\n" +
 103                                         "    \"query\": {\n" +
 104                                         "        \"bool\": {\n" +
 105                                         "            \"should\": {\n" +
 106                                         "                    \"match\": {\n" +
 107                                         "                        \""+MATCH_QUERY_KEY+"\": "+MATCH_QUERY_VALUE+"\n" +
 108                                         "                    }\n" +
 109                                         "                }\n" +
 110                                         "        }\n" +
 111                                         "    }\n" +
 112                                         "}";
 113         private static final String RANGE_QUERY_KEY = "timestamp";
 114         private static final String RANGE_QUERY_LTEND = "2017-08-10T20:00:00.0Z";
 115         private static final String RANGE_QUERY = "{\n" +
 116                         "    \"query\": {\n" +
 117                         "        \"range\" : {\n" +
 118                         "            \""+RANGE_QUERY_KEY+"\" : {\n" +
 119                         "                \"lte\" : \""+RANGE_QUERY_LTEND+"\",\n" +
 120                         "                \"boost\": 2.0\n" +
 121                         "            }\n" +
 122                         "        }\n" +
 123                         "    }\n" +
 124                         "}";
 125         private static final String RANGEBOOL_QUERY="{\n" +
 126                         "    \"query\": {\n" +
 127                         "        \"bool\": {\n" +
 128                         "            \"must\": [\n" +
 129                         "                {\n" +
 130                         "                    \"match\": {\n" +
 131                         "                        \"is-required\": true\n" +
 132                         "                    }\n" +
 133                         "                },\n" +
 134                         "                {\n" +
 135                         "                    \"regexp\": {\n" +
 136                         "                        \"node-id\": {\n" +
 137                         "                            \"max_determinized_states\": 10000,\n" +
 138                         "                            \"flags\": \"ALL\",\n" +
 139                         "                            \"value\": \"sim.*\"\n" +
 140                         "                        }\n" +
 141                         "                    }\n" +
 142                         "                }\n" +
 143                         "            ]\n" +
 144                         "        }\n" +
 145                         "    }\n" +
 146                         "}";
 147         private static final String AGG_FIELD = "severity";
 148         private static final String AGG_QUERY = "{\n" +
 149                         "    \"query\": {\n" +
 150                         "        \"match_all\": {}\n" +
 151                         "    },\n" +
 152                         "    \"aggs\": {\n" +
 153                         "        \"severity\": {\n" +
 154                         "            \"terms\": {\n" +
 155                         "                \"field\": \""+AGG_FIELD+"\"\n" +
 156                         "            }\n" +
 157                         "        }\n" +
 158                         "    }\n" +
 159                         "}";
 160         private static final long FROMANDSIZE_QUERY_SIZE = 20;
 161         private static final long FROMANDSIZE_QUERY_FROM = 120;
 162         private static final String FROMANDSIZE_QUERY = "{\n" +
 163                         "    \"size\": "+FROMANDSIZE_QUERY_SIZE+",\n" +
 164                         "    \"query\": {\n" +
 165                         "        \"match_all\": {}\n" +
 166                         "    },\n" +
 167                         "    \"from\":"+FROMANDSIZE_QUERY_FROM+"\n" +
 168                         "}";
 169         private static final String TERMQUERY_KEY = "node-id";
 170         private static final String TERMQUERY_VALUE = "abc";
 171         private static final String TERM_QUERY = "{\n" +
 172                         "    \"query\": {\n" +
 173                         "        \"term\": {\n" +
 174                         "            \""+TERMQUERY_KEY+"\": \""+TERMQUERY_VALUE+"\"\n" +
 175                         "        }\n" +
 176                         "    }\n" +
 177                         "}";
 178         private static final String SORTING_PROPERTY = "node-id";
 179         private static final String SORTING_QUERY_ASC = "{\n" +
 180                         "    \"query\": {\n" +
 181                         "        \"match_all\": {}\n" +
 182                         "    },\n" +
 183                         "    \"sort\": [\n" +
 184                         "        {\n" +
 185                         "            \""+SORTING_PROPERTY+"\": {\n" +
 186                         "                \"order\": \"asc\"\n" +
 187                         "            }\n" +
 188                         "        }\n" +
 189                         "    ]\n" +
 190                         "}";
 191         private static final String SORTING_QUERY_DESC = "{\n" +
 192                         "    \"query\": {\n" +
 193                         "        \"match_all\": {}\n" +
 194                         "    },\n" +
 195                         "    \"sort\": [\n" +
 196                         "        {\n" +
 197                         "            \""+SORTING_PROPERTY+"\": {\n" +
 198                         "                \"order\": \"desc\"\n" +
 199                         "            }\n" +
 200                         "        }\n" +
 201                         "    ]\n" +
 202                         "}";
 203
 204         private void testEquals(String message,String json, QueryBuilder query) {
 205                 this.testEquals(message, json, query,true);
 206         }
 207         private void testEquals(String message,String json, QueryBuilder query,boolean strict) {
 208
 209                 try {
 210                         System.out.println("===test if "+message+"===================");
 211                         System.out.println("orig  : "+trim(json));
 212                         System.out.println("totest: "+query.toJSON().trim());
 213                         JSONAssert.assertEquals(json,query.toJSON(),strict);
 214                 } catch (JSONException e) {
 215                         fail(message);
 216                 }
 217         }
 218
 219         private String trim(String json) {
 220                 return json.trim().replaceAll("\n","").replaceAll(" ", "");
 221         }
 222
 223         @Test
 224         public void testMatchAll() {
 225                 testEquals("match all query is wrong", MATCH_ALL_QUERY, QueryBuilders.matchAllQuery());
 226         }
 227         @Test
 228         public void testMatch() {
 229                 testEquals("match query is wrong", MATCH_QUERY, QueryBuilders.matchQuery(MATCH_QUERY_KEY, MATCH_QUERY_VALUE));
 230         }
 231         @Test
 232         public void testBoolMust() {
 233                 testEquals("bool query is wrong", BOOL_QUERY_MUST,
 234                                 QueryBuilders.boolQuery().
 235                                 must(QueryBuilders.matchQuery(MATCH_QUERY_KEY, MATCH_QUERY_VALUE)).
 236                                 must(QueryBuilders.matchQuery(MATCH_QUERY_KEY2, MATCH_QUERY_VALUE2)));
 237         }
 238         @Test
 239         public void testBoolMustSingle() {
 240                 testEquals("bool single query is wrong", BOOL_QUERY_MUST_SINGLE,
 241                                 QueryBuilders.boolQuery().
 242                                 must(QueryBuilders.matchQuery(MATCH_QUERY_KEY, MATCH_QUERY_VALUE)));
 243         }
 244         @Test
 245         public void testBoolShould() {
 246                 testEquals("bool query is wrong", BOOL_QUERY_SHOULD,
 247                                 QueryBuilders.boolQuery().
 248                                 should(QueryBuilders.matchQuery(MATCH_QUERY_KEY, MATCH_QUERY_VALUE)).
 249                                 should(QueryBuilders.matchQuery(MATCH_QUERY_KEY2, MATCH_QUERY_VALUE2)));
 250         }
 251         @Test
 252         public void testBoolShouldSingle() {
 253                 testEquals("bool single query is wrong", BOOL_QUERY_SHOULD_SINGLE,
 254                                 QueryBuilders.boolQuery().
 255                                 should(QueryBuilders.matchQuery(MATCH_QUERY_KEY, MATCH_QUERY_VALUE)));
 256         }
 257         @Test
 258         public void testRange() {
 259                 testEquals("range query is wrong", RANGE_QUERY, QueryBuilders.rangeQuery(RANGE_QUERY_KEY).lte(RANGE_QUERY_LTEND));
 260
 261         }
 262         @Test
 263         public void testAggregation() {
 264                 testEquals("aggregation query is wrong",AGG_QUERY, QueryBuilders.matchAllQuery().aggregations(AGG_FIELD));
 265         }
 266         @Test
 267         public void testSizeAndFrom() {
 268                 testEquals("aggregation query is wrong",FROMANDSIZE_QUERY, QueryBuilders.matchAllQuery().size(FROMANDSIZE_QUERY_SIZE).from(FROMANDSIZE_QUERY_FROM));
 269         }
 270         @Test
 271         public void testRegex() {
 272                 testEquals("range and bool query is wrong1",RANGEBOOL_QUERY,QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("is-required", true)).must(QueryBuilders.regex("node-id", DbFilter.createDatabaseRegex("sim*"))),false);
 273                 BoolQueryBuilder q = QueryBuilders.boolQuery().must(QueryBuilders.regex("node-id", DbFilter.createDatabaseRegex("sim*")));
 274                 q.must(QueryBuilders.matchQuery("is-required", true));
 275                 testEquals("range and bool query is wrong2",RANGEBOOL_QUERY,q,false);
 276         }
 277         @Test
 278         public void testTerm() {
 279                 testEquals("term query is wrong", TERM_QUERY, QueryBuilders.termQuery(TERMQUERY_KEY, TERMQUERY_VALUE));
 280         }
 281         @Test
 282         public void testSorting() {
 283                 testEquals("sortorder is wrong",SORTING_QUERY_ASC, QueryBuilders.matchAllQuery().sort(SORTING_PROPERTY, SortOrder.ASCENDING));
 284                 testEquals("sortorder is wrong",SORTING_QUERY_DESC, QueryBuilders.matchAllQuery().sort(SORTING_PROPERTY, SortOrder.DESCENDING));
 285         }
 286 }