sparkybe-onap-service/src/test/java/org/onap/aai/sparky/sync/AbstractEntitySynchronizerTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017-2018 Amdocs
   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.aai.sparky.sync;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.security.SecureRandom;
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.regex.Pattern;
  34
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.mockito.Mockito;
  38 import org.onap.aai.cl.api.Logger;
  39 import org.onap.aai.cl.eelf.LoggerFactory;
  40 import org.onap.aai.restclient.client.OperationResult;
  41 import org.onap.aai.sparky.config.oxm.SearchableEntityLookup;
  42 import org.onap.aai.sparky.config.oxm.SearchableOxmEntityDescriptor;
  43 import org.onap.aai.sparky.dal.ActiveInventoryAdapter;
  44 import org.onap.aai.sparky.search.SearchServiceAdapter;
  45 import org.onap.aai.sparky.dal.NetworkTransaction;
  46 import org.onap.aai.sparky.dal.rest.HttpMethod;
  47 import org.onap.aai.sparky.sync.config.NetworkStatisticsConfig;
  48
  49
  50
  51 public class AbstractEntitySynchronizerTest {
  52
  53         public class QuantumSynchronizer extends AbstractEntitySynchronizer {
  54
  55                 private boolean amIDone;
  56                 private SearchableEntityLookup searchableEntityLookup;
  57
  58                 protected QuantumSynchronizer(Logger logger, String syncName, int numSyncWorkers, int numActiveInventoryWorkers,
  59                                 int numElasticsearchWorkers, String indexName, NetworkStatisticsConfig aaiStatConfig,
  60                                 NetworkStatisticsConfig esStatConfig) throws Exception {
  61                         super(logger, syncName, numSyncWorkers, numActiveInventoryWorkers, numElasticsearchWorkers, indexName,
  62                                         aaiStatConfig, esStatConfig);
  63
  64                         amIDone = false;
  65
  66                 }
  67
  68                 public void setSearchableEntityLookup(SearchableEntityLookup searchableEntityLookup) {
  69                         this.searchableEntityLookup = searchableEntityLookup;
  70                 }
  71
  72                 public void initCounters() {
  73                         if (this.searchableEntityLookup != null) {
  74                                 this.aaiEntityStats
  75                                                 .intializeEntityCounters(searchableEntityLookup.getSearchableEntityDescriptors().keySet());
  76                                 this.esEntityStats
  77                                                 .intializeEntityCounters(searchableEntityLookup.getSearchableEntityDescriptors().keySet());
  78
  79                         }
  80                 }
  81
  82                 public void setSyncDone(boolean done) {
  83                         this.amIDone = done;
  84                 }
  85
  86                 @Override
  87                 protected boolean isSyncDone() {
  88                         return amIDone;
  89                 }
  90
  91         }
  92
  93         private static Logger LOG = LoggerFactory.getInstance().getLogger(AbstractEntitySynchronizerTest.class);
  94         private static SecureRandom secureRandom = new SecureRandom();
  95
  96         private QuantumSynchronizer quantumSync;
  97         private NetworkStatisticsConfig aaiStatConfig;
  98         private NetworkStatisticsConfig esStatConfig;
  99         private SearchServiceAdapter searchServiceAdapter;
 100         private ActiveInventoryAdapter aaiAdapter;
 101         private SearchableEntityLookup searchableEntityLookup;
 102
 103
 104         @Before
 105         public void init() throws Exception {
 106
 107                 aaiStatConfig = new NetworkStatisticsConfig();
 108
 109                 aaiStatConfig.setNumSamplesPerThreadForRunningAverage(100);
 110
 111                 aaiStatConfig.setBytesHistogramLabel("[Response Size In Bytes]");
 112                 aaiStatConfig.setBytesHistogramMaxYAxis(1000000L);
 113                 aaiStatConfig.setBytesHistogramNumBins(20);
 114                 aaiStatConfig.setBytesHistogramNumDecimalPoints(2);
 115
 116                 aaiStatConfig.setQueueLengthHistogramLabel("[Queue Item Length]");
 117                 aaiStatConfig.setQueueLengthHistogramMaxYAxis(20000);
 118                 aaiStatConfig.setQueueLengthHistogramNumBins(20);
 119                 aaiStatConfig.setQueueLengthHistogramNumDecimalPoints(2);
 120
 121                 aaiStatConfig.setTaskAgeHistogramLabel("[Task Age In Ms]");
 122                 aaiStatConfig.setTaskAgeHistogramMaxYAxis(600000L);
 123                 aaiStatConfig.setTaskAgeHistogramNumBins(20);
 124                 aaiStatConfig.setTaskAgeHistogramNumDecimalPoints(2);
 125
 126                 aaiStatConfig.setResponseTimeHistogramLabel("[Response Time In Ms]");
 127                 aaiStatConfig.setResponseTimeHistogramMaxYAxis(1000L);
 128                 aaiStatConfig.setResponseTimeHistogramNumBins(20);
 129                 aaiStatConfig.setResponseTimeHistogramNumDecimalPoints(2);
 130
 131                 aaiStatConfig.setTpsHistogramLabel("[Transactions Per Second]");
 132         aaiStatConfig.setTpsHistogramMaxYAxis(100);
 133                 aaiStatConfig.setTpsHistogramNumBins(20);
 134                 aaiStatConfig.setTpsHistogramNumDecimalPoints(2);
 135
 136                 esStatConfig = new NetworkStatisticsConfig();
 137
 138                 esStatConfig.setNumSamplesPerThreadForRunningAverage(100);
 139
 140                 esStatConfig.setBytesHistogramLabel("[Response Size In Bytes]");
 141                 esStatConfig.setBytesHistogramMaxYAxis(1000000L);
 142                 esStatConfig.setBytesHistogramNumBins(20);
 143                 esStatConfig.setBytesHistogramNumDecimalPoints(2);
 144
 145                 esStatConfig.setQueueLengthHistogramLabel("[Queue Item Length]");
 146                 esStatConfig.setQueueLengthHistogramMaxYAxis(20000);
 147                 esStatConfig.setQueueLengthHistogramNumBins(20);
 148                 esStatConfig.setQueueLengthHistogramNumDecimalPoints(2);
 149
 150                 esStatConfig.setTaskAgeHistogramLabel("[Task Age In Ms]");
 151                 esStatConfig.setTaskAgeHistogramMaxYAxis(600000L);
 152                 esStatConfig.setTaskAgeHistogramNumBins(20);
 153                 esStatConfig.setTaskAgeHistogramNumDecimalPoints(2);
 154
 155                 esStatConfig.setResponseTimeHistogramLabel("[Response Time In Ms]");
 156                 esStatConfig.setResponseTimeHistogramMaxYAxis(10000L);
 157                 esStatConfig.setResponseTimeHistogramNumBins(20);
 158                 esStatConfig.setResponseTimeHistogramNumDecimalPoints(2);
 159
 160                 esStatConfig.setTpsHistogramLabel("[Transactions Per Second]");
 161                 esStatConfig.setTpsHistogramMaxYAxis(100);
 162                 esStatConfig.setTpsHistogramNumBins(20);
 163                 esStatConfig.setTpsHistogramNumDecimalPoints(2);
 164
 165                 searchServiceAdapter = Mockito.mock(SearchServiceAdapter.class);
 166                 aaiAdapter = Mockito.mock(ActiveInventoryAdapter.class);
 167
 168         }
 169
 170         @Test
 171         public void validateNetworkStatConfig() {
 172
 173                 // validate aaiStatConfig
 174
 175                 assertEquals(100, aaiStatConfig.getNumSamplesPerThreadForRunningAverage());
 176
 177                 assertEquals("[Response Size In Bytes]",aaiStatConfig.getBytesHistogramLabel());
 178                 assertEquals(1000000L,aaiStatConfig.getBytesHistogramMaxYAxis());
 179                 assertEquals(20,aaiStatConfig.getBytesHistogramNumBins());
 180                 assertEquals(2,aaiStatConfig.getBytesHistogramNumDecimalPoints());
 181
 182                 assertEquals("[Queue Item Length]",aaiStatConfig.getQueueLengthHistogramLabel());
 183                 assertEquals(20000,aaiStatConfig.getQueueLengthHistogramMaxYAxis());
 184                 assertEquals(20,aaiStatConfig.getQueueLengthHistogramNumBins());
 185                 assertEquals(2,aaiStatConfig.getQueueLengthHistogramNumDecimalPoints());
 186
 187                 assertEquals("[Task Age In Ms]",aaiStatConfig.getTaskAgeHistogramLabel());
 188                 assertEquals(600000L,aaiStatConfig.getTaskAgeHistogramMaxYAxis());
 189                 assertEquals(20,aaiStatConfig.getTaskAgeHistogramNumBins());
 190                 assertEquals(2,aaiStatConfig.getTaskAgeHistogramNumDecimalPoints());
 191
 192                 assertEquals("[Response Time In Ms]",aaiStatConfig.getResponseTimeHistogramLabel());
 193                 assertEquals(1000L,aaiStatConfig.getResponseTimeHistogramMaxYAxis());
 194                 assertEquals(20,aaiStatConfig.getResponseTimeHistogramNumBins());
 195                 assertEquals(2, aaiStatConfig.getResponseTimeHistogramNumDecimalPoints());
 196
 197                 assertEquals("[Transactions Per Second]",aaiStatConfig.getTpsHistogramLabel());
 198                 assertEquals(100,aaiStatConfig.getTpsHistogramMaxYAxis());
 199                 assertEquals(20,aaiStatConfig.getTpsHistogramNumBins());
 200                 assertEquals(2,aaiStatConfig.getTpsHistogramNumDecimalPoints());
 201
 202                 // validate esStatConfig
 203
 204                 assertEquals(100, esStatConfig.getNumSamplesPerThreadForRunningAverage());
 205
 206                 assertEquals("[Response Size In Bytes]",esStatConfig.getBytesHistogramLabel());
 207                 assertEquals(1000000L,esStatConfig.getBytesHistogramMaxYAxis());
 208                 assertEquals(20,esStatConfig.getBytesHistogramNumBins());
 209                 assertEquals(2,esStatConfig.getBytesHistogramNumDecimalPoints());
 210
 211                 assertEquals("[Queue Item Length]",esStatConfig.getQueueLengthHistogramLabel());
 212                 assertEquals(20000,esStatConfig.getQueueLengthHistogramMaxYAxis());
 213                 assertEquals(20,esStatConfig.getQueueLengthHistogramNumBins());
 214                 assertEquals(2,esStatConfig.getQueueLengthHistogramNumDecimalPoints());
 215
 216                 assertEquals("[Task Age In Ms]",esStatConfig.getTaskAgeHistogramLabel());
 217                 assertEquals(600000L,esStatConfig.getTaskAgeHistogramMaxYAxis());
 218                 assertEquals(20,esStatConfig.getTaskAgeHistogramNumBins());
 219                 assertEquals(2,esStatConfig.getTaskAgeHistogramNumDecimalPoints());
 220
 221                 assertEquals("[Response Time In Ms]",esStatConfig.getResponseTimeHistogramLabel());
 222                 assertEquals(10000L,esStatConfig.getResponseTimeHistogramMaxYAxis());
 223                 assertEquals(20,esStatConfig.getResponseTimeHistogramNumBins());
 224                 assertEquals(2, esStatConfig.getResponseTimeHistogramNumDecimalPoints());
 225
 226                 assertEquals("[Transactions Per Second]",esStatConfig.getTpsHistogramLabel());
 227                 assertEquals(100,esStatConfig.getTpsHistogramMaxYAxis());
 228                 assertEquals(20,esStatConfig.getTpsHistogramNumBins());
 229                 assertEquals(2,esStatConfig.getTpsHistogramNumDecimalPoints());
 230
 231         }
 232
 233         @Test
 234         public void validateBasicConstruction() throws Exception {
 235
 236                 quantumSync = new QuantumSynchronizer(LOG, "quanumSynchronizer", 5, 5, 5, "quantum-search-index", aaiStatConfig,
 237                                 esStatConfig);
 238
 239                 quantumSync.setAaiAdapter(aaiAdapter);
 240                 quantumSync.setSearchServiceAdapter(searchServiceAdapter);
 241
 242                 quantumSync.clearCache();
 243
 244                 assertNotNull(quantumSync.getAaiAdapter());
 245                 assertNotNull(quantumSync.getSearchServiceAdapter());
 246                 assertEquals("quantum-search-index", quantumSync.getIndexName());
 247
 248                 quantumSync.setIndexName("new-search-index-name");
 249                 assertEquals("new-search-index-name", quantumSync.getIndexName());
 250
 251                 quantumSync.shutdownExecutors();
 252         }
 253
 254         private static String REST_STAT_LINE_FORMAT = ".*%s.*1XX:.*%d.*2XX:.*%d.*3XX:.*%d.*4XX:.*%d.*5XX:.*%d.*6XX:.*%d.*";
 255         private static String ENTITY_STATS_LINE_FORMAT = ".*%s.*TOTAL:.*%d.*FOUND:.*%d.*NO_PAYLOAD:.*%d.*NOT_FOUND:.*%d.*NUM_RETRIES:.*%d.*ERROR:.*%d.*";
 256
 257         private boolean reportContainsRestStatistics(String testString, HttpMethod httpMethod, long oneXX, long twoXX,
 258                         long threeXX, long fourXX, long fiveXX, long sixXX) {
 259
 260                 Pattern pattern = Pattern.compile(String.format(REST_STAT_LINE_FORMAT, httpMethod.toString(), oneXX, twoXX,
 261                                 threeXX, fourXX, fiveXX, sixXX));
 262
 263                 String lines[] = testString.split("\\r?\\n");
 264
 265                 /*
 266                  * if we get a match on any of the lines in the report, then we
 267                  * succeeded
 268                  */
 269
 270                 for (String line : lines) {
 271                         if (pattern.matcher(line).matches()) {
 272                                 return true;
 273                         }
 274                 }
 275
 276                 return false;
 277         }
 278
 279         private boolean reportContainsEntityStatistics(String testString, String entityType, long total, long found,
 280                         long noPayload, long notFound, long numRetries, long numErrors) {
 281
 282                 Pattern pattern = Pattern.compile(String.format(ENTITY_STATS_LINE_FORMAT, entityType, total, found,
 283                                 noPayload, notFound, numRetries, numErrors));
 284
 285                 String lines[] = testString.split("\\r?\\n");
 286
 287                 /*
 288                  * if we get a match on any of the lines in the report, then we
 289                  * succeeded
 290                  */
 291
 292                 for (String line : lines) {
 293                         if (pattern.matcher(line).matches()) {
 294                                 return true;
 295                         }
 296                 }
 297
 298                 return false;
 299         }
 300
 301
 302         @Test
 303         public void validateStatisticTrackingAndReporting() throws Exception {
 304
 305                 quantumSync = new QuantumSynchronizer(LOG, "quanumSynchronizer", 5, 5, 5, "quantum-search-index", aaiStatConfig,
 306                                 esStatConfig);
 307
 308                 quantumSync.setAaiAdapter(aaiAdapter);
 309                 quantumSync.setSearchServiceAdapter(searchServiceAdapter);
 310
 311                 searchableEntityLookup = new SearchableEntityLookup();
 312
 313                 Map<String,SearchableOxmEntityDescriptor> searchableDescriptors = new HashMap<String,SearchableOxmEntityDescriptor>();
 314
 315                 SearchableOxmEntityDescriptor complexDescriptor = new SearchableOxmEntityDescriptor();
 316                 complexDescriptor.setEntityName("complex");
 317                 List<String> pkeyNames = new ArrayList<String>();
 318                 pkeyNames.add("physical-location-id");
 319
 320                 complexDescriptor.setPrimaryKeyAttributeNames(pkeyNames);
 321                 complexDescriptor.setSearchableAttributes(pkeyNames);
 322
 323                 searchableDescriptors.put("complex", complexDescriptor);
 324
 325                 searchableEntityLookup.setSearchableEntityDescriptors(searchableDescriptors);
 326
 327                 quantumSync.setSearchableEntityLookup(searchableEntityLookup);
 328                 quantumSync.initCounters();
 329
 330                 int randomMaxTimesToPegCounters = secureRandom.nextInt(1000);
 331
 332                 NetworkTransaction txn = null;
 333                 OperationResult opResult = null;
 334
 335
 336                 /*
 337                  * The result of this block is that for all HttpMethod types [ PUT, POST, GET, etc ] we'll peg a complex entity
 338                  * type counter a random number of times (set before the for loop, and for each status code category 1XX -> 6XX.
 339                  */
 340
 341                 // GET, PUT, POST, DELETE, PATCH, HEAD
 342                 for (HttpMethod httpMethod : HttpMethod.values()) {
 343
 344                         // for randomMaxTimesToPegCounters
 345                         for (int numTimesToPegCounter = 0; numTimesToPegCounter < randomMaxTimesToPegCounters; numTimesToPegCounter++) {
 346                                 txn = new NetworkTransaction();
 347                                 txn.setOperationType(httpMethod);
 348                                 txn.setEntityType("complex");
 349
 350                                 /*
 351                                  * set the txn optime to a random value between 0 and 10000 ms.
 352                                  * Over thousands of counter statistics the random sample
 353                                  * averages should be approximately uniform, but is highly
 354                                  * dependent on the pseudo-RNG.
 355                                  */
 356                                 txn.setOpTimeInMs(secureRandom.nextInt(10000));
 357
 358                                 // 1XX, 2XX, 3XX, 4XX, 5XX, 6XX
 359                                 for ( int resultCode = 100; resultCode < 700; resultCode += 100) {
 360                                         opResult = new OperationResult();
 361                                         opResult.setResultCode(resultCode);
 362
 363                                         txn.setOperationResult(opResult);
 364
 365                                         // peg both AAI and ES statistics
 366
 367                                         quantumSync.updateActiveInventoryCounters(txn);
 368                                         quantumSync.updateActiveInventoryCounters(httpMethod, "complex", opResult);
 369
 370                                         quantumSync.updateElasticSearchCounters(txn);
 371                                         quantumSync.updateElasticSearchCounters(httpMethod, "complex", opResult);
 372
 373                                 }
 374                         }
 375                 }
 376
 377                 for (int numTimesToPegCounter = 0; numTimesToPegCounter < randomMaxTimesToPegCounters; numTimesToPegCounter++) {
 378                         quantumSync.incActiveInventoryWorkOnHandCounter();
 379                         quantumSync.incElasticSearchWorkOnHandCounter();
 380                 }
 381
 382                 assertEquals( randomMaxTimesToPegCounters, quantumSync.aaiWorkOnHand.get());
 383                 assertEquals( randomMaxTimesToPegCounters, quantumSync.esWorkOnHand.get());
 384
 385                 /*
 386                  * now we'll generate various reports and try to validate the output
 387                  */
 388
 389                 String aaiStatsReport = quantumSync.getActiveInventoryStatisticsReport();
 390
 391                 /*
 392                  * We double the expected validation check number because we peg each
 393                  * counter in each category twice (with different APIs for the same
 394                  * entity.
 395                  */
 396
 397                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.DELETE, randomMaxTimesToPegCounters * 2,
 398                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 399                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 400
 401                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.PUT, randomMaxTimesToPegCounters * 2,
 402                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 403                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 404
 405                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.POST, randomMaxTimesToPegCounters * 2,
 406                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 407                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 408
 409                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.GET, randomMaxTimesToPegCounters * 2,
 410                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 411                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 412
 413                 long total = (randomMaxTimesToPegCounters*2)*6;
 414                 long found = randomMaxTimesToPegCounters*2;
 415                 long noPayload = (randomMaxTimesToPegCounters*2)*6;
 416                 long notFound = 0;
 417                 long numRetries = 0;
 418                 long numErrors = (randomMaxTimesToPegCounters*2)*5;
 419
 420                 assertTrue(reportContainsEntityStatistics(aaiStatsReport, "complex", total, found,
 421                                 noPayload, notFound, numRetries, numErrors));
 422
 423                 String esStatsReport = quantumSync.getElasticSearchStatisticsReport();
 424
 425                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.DELETE, randomMaxTimesToPegCounters * 2,
 426                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 427                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 428
 429                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.PUT, randomMaxTimesToPegCounters * 2,
 430                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 431                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 432
 433                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.POST, randomMaxTimesToPegCounters * 2,
 434                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 435                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 436
 437                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.GET, randomMaxTimesToPegCounters * 2,
 438                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2,
 439                                 randomMaxTimesToPegCounters * 2, randomMaxTimesToPegCounters * 2));
 440
 441
 442                 assertNotNull(quantumSync.getStatReport(10000L, false));
 443                 assertNotNull(quantumSync.getStatReport(20000L, true));
 444
 445                 for (int numTimesToPegCounter = 0; numTimesToPegCounter < randomMaxTimesToPegCounters; numTimesToPegCounter++) {
 446                         quantumSync.decActiveInventoryWorkOnHandCounter();
 447                         quantumSync.decElasticSearchWorkOnHandCounter();
 448                 }
 449
 450                 assertEquals( 0, quantumSync.aaiWorkOnHand.get());
 451                 assertEquals( 0, quantumSync.esWorkOnHand.get());
 452
 453                 /*
 454                  * Validate stat reports display zero stats for complex
 455                  */
 456
 457                 quantumSync.resetCounters();
 458
 459                 aaiStatsReport = quantumSync.getActiveInventoryStatisticsReport();
 460
 461                 /*
 462                  * We double the expected validation check number because we peg each
 463                  * counter in each category twice (with different APIs for the same
 464                  * entity.
 465                  */
 466
 467                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.DELETE, 0, 0, 0, 0, 0, 0));
 468                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.PUT, 0, 0, 0, 0, 0, 0));
 469                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.POST, 0, 0, 0, 0, 0, 0));
 470                 assertTrue(reportContainsRestStatistics(aaiStatsReport, HttpMethod.GET, 0, 0, 0, 0, 0, 0));
 471
 472                 assertTrue(reportContainsEntityStatistics(aaiStatsReport, "complex", 0, 0, 0, 0, 0, 0));
 473
 474                 esStatsReport = quantumSync.getElasticSearchStatisticsReport();
 475
 476                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.DELETE, 0, 0, 0, 0, 0, 0));
 477                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.PUT, 0, 0, 0, 0, 0, 0));
 478                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.POST, 0, 0, 0, 0, 0, 0));
 479                 assertTrue(reportContainsRestStatistics(esStatsReport, HttpMethod.GET, 0, 0, 0, 0, 0, 0));
 480
 481                 quantumSync.shutdownExecutors();
 482         }
 483
 484 }