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

   1 package org.onap.aai.sparky.sync;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNotNull;
   5
   6 import java.security.SecureRandom;
   7 import java.util.ArrayList;
   8 import java.util.HashMap;
   9 import java.util.List;
  10 import java.util.Map;
  11
  12 import javax.ws.rs.core.MediaType;
  13
  14 import org.junit.Before;
  15 import org.junit.Test;
  16 import org.mockito.Matchers;
  17 import org.mockito.Mockito;
  18 import org.onap.aai.restclient.client.OperationResult;
  19 import org.onap.aai.sparky.aggregation.sync.AggregationSynchronizer;
  20 import org.onap.aai.sparky.config.oxm.OxmEntityDescriptor;
  21 import org.onap.aai.sparky.config.oxm.OxmEntityLookup;
  22 import org.onap.aai.sparky.dal.ActiveInventoryAdapter;
  23 import org.onap.aai.sparky.dal.ElasticSearchAdapter;
  24 import org.onap.aai.sparky.sync.config.ElasticSearchSchemaConfig;
  25 import org.onap.aai.sparky.sync.config.NetworkStatisticsConfig;
  26 import org.onap.aai.sparky.sync.enumeration.OperationState;
  27 import org.onap.aai.sparky.sync.enumeration.SynchronizerState;
  28 import org.onap.aai.sparky.util.TestResourceLoader;
  29
  30 public class AggregationSynchronizerTest {
  31
  32         //private static Logger LOG = LoggerFactory.getInstance().getLogger(AggregationSynchronizerTest.class);
  33         private static SecureRandom secureRandom = new SecureRandom();
  34         private AggregationSynchronizer aggregationSynchronizer;
  35
  36         private ElasticSearchSchemaConfig esSchemaConfig;
  37         private NetworkStatisticsConfig aaiStatConfig;
  38         private NetworkStatisticsConfig esStatConfig;
  39         private OxmEntityLookup oxmEntityLookup;
  40         private ElasticSearchAdapter esAdapter;
  41         private ActiveInventoryAdapter aaiAdapter;
  42
  43
  44
  45         @Before
  46         public void init() throws Exception {
  47
  48                 esSchemaConfig = new ElasticSearchSchemaConfig();
  49                 esSchemaConfig.setIndexDocType("default");
  50                 esSchemaConfig.setIndexMappingsFileName(null);
  51                 esSchemaConfig.setIndexName("aggregation-index-name");
  52                 esSchemaConfig.setIndexSettingsFileName(null);
  53
  54
  55                 aaiStatConfig = new NetworkStatisticsConfig();
  56
  57                 aaiStatConfig.setNumSamplesPerThreadForRunningAverage(100);
  58
  59                 aaiStatConfig.setBytesHistogramLabel("[Response Size In Bytes]");
  60                 aaiStatConfig.setBytesHistogramMaxYAxis(1000000L);
  61                 aaiStatConfig.setBytesHistogramNumBins(20);
  62                 aaiStatConfig.setBytesHistogramNumDecimalPoints(2);
  63
  64                 aaiStatConfig.setQueueLengthHistogramLabel("[Queue Item Length]");
  65                 aaiStatConfig.setQueueLengthHistogramMaxYAxis(20000);
  66                 aaiStatConfig.setQueueLengthHistogramNumBins(20);
  67                 aaiStatConfig.setQueueLengthHistogramNumDecimalPoints(2);
  68
  69                 aaiStatConfig.setTaskAgeHistogramLabel("[Task Age In Ms]");
  70                 aaiStatConfig.setTaskAgeHistogramMaxYAxis(600000L);
  71                 aaiStatConfig.setTaskAgeHistogramNumBins(20);
  72                 aaiStatConfig.setTaskAgeHistogramNumDecimalPoints(2);
  73
  74                 aaiStatConfig.setResponseTimeHistogramLabel("[Response Time In Ms]");
  75                 aaiStatConfig.setResponseTimeHistogramMaxYAxis(1000L);
  76                 aaiStatConfig.setResponseTimeHistogramNumBins(20);
  77                 aaiStatConfig.setResponseTimeHistogramNumDecimalPoints(2);
  78
  79                 aaiStatConfig.setTpsHistogramLabel("[Transactions Per Second]");
  80         aaiStatConfig.setTpsHistogramMaxYAxis(100);
  81                 aaiStatConfig.setTpsHistogramNumBins(20);
  82                 aaiStatConfig.setTpsHistogramNumDecimalPoints(2);
  83
  84                 esStatConfig = new NetworkStatisticsConfig();
  85
  86                 esStatConfig.setNumSamplesPerThreadForRunningAverage(100);
  87
  88                 esStatConfig.setBytesHistogramLabel("[Response Size In Bytes]");
  89                 esStatConfig.setBytesHistogramMaxYAxis(1000000L);
  90                 esStatConfig.setBytesHistogramNumBins(20);
  91                 esStatConfig.setBytesHistogramNumDecimalPoints(2);
  92
  93                 esStatConfig.setQueueLengthHistogramLabel("[Queue Item Length]");
  94                 esStatConfig.setQueueLengthHistogramMaxYAxis(20000);
  95                 esStatConfig.setQueueLengthHistogramNumBins(20);
  96                 esStatConfig.setQueueLengthHistogramNumDecimalPoints(2);
  97
  98                 esStatConfig.setTaskAgeHistogramLabel("[Task Age In Ms]");
  99                 esStatConfig.setTaskAgeHistogramMaxYAxis(600000L);
 100                 esStatConfig.setTaskAgeHistogramNumBins(20);
 101                 esStatConfig.setTaskAgeHistogramNumDecimalPoints(2);
 102
 103                 esStatConfig.setResponseTimeHistogramLabel("[Response Time In Ms]");
 104                 esStatConfig.setResponseTimeHistogramMaxYAxis(10000L);
 105                 esStatConfig.setResponseTimeHistogramNumBins(20);
 106                 esStatConfig.setResponseTimeHistogramNumDecimalPoints(2);
 107
 108                 esStatConfig.setTpsHistogramLabel("[Transactions Per Second]");
 109                 esStatConfig.setTpsHistogramMaxYAxis(100);
 110                 esStatConfig.setTpsHistogramNumBins(20);
 111                 esStatConfig.setTpsHistogramNumDecimalPoints(2);
 112
 113                 oxmEntityLookup = new OxmEntityLookup();
 114
 115                 esAdapter = Mockito.mock(ElasticSearchAdapter.class);
 116                 aaiAdapter = Mockito.mock(ActiveInventoryAdapter.class);
 117
 118                 Map<String,OxmEntityDescriptor> oxmEntityDescriptors = new HashMap<String,OxmEntityDescriptor>();
 119
 120                 OxmEntityDescriptor complexDescriptor = new OxmEntityDescriptor();
 121                 complexDescriptor.setEntityName("complex");
 122                 List<String> pkeyNames = new ArrayList<String>();
 123                 pkeyNames.add("physical-location-id");
 124
 125                 complexDescriptor.setPrimaryKeyAttributeNames(pkeyNames);
 126
 127                 oxmEntityDescriptors.put("complex", complexDescriptor);
 128
 129                 oxmEntityLookup.setEntityDescriptors(oxmEntityDescriptors);
 130
 131
 132
 133         }
 134
 135         @Test
 136         public void validateBasicConstruction() throws Exception {
 137
 138                 aggregationSynchronizer = new AggregationSynchronizer("complex", esSchemaConfig, 5, 5, 5, aaiStatConfig,
 139                                 esStatConfig, oxmEntityLookup);
 140
 141                 aggregationSynchronizer.setAaiAdapter(aaiAdapter);
 142                 aggregationSynchronizer.setElasticSearchAdapter(esAdapter);
 143
 144                 assertNotNull(aggregationSynchronizer.getAaiAdapter());
 145                 assertNotNull(aggregationSynchronizer.getElasticSearchAdapter());
 146
 147         }
 148
 149         @Test
 150         public void validateSmallSync() throws Exception {
 151
 152                 aggregationSynchronizer = new AggregationSynchronizer("complex", esSchemaConfig, 5, 5, 5, aaiStatConfig,
 153                                 esStatConfig, oxmEntityLookup);
 154
 155                 aggregationSynchronizer.setAaiAdapter(aaiAdapter);
 156                 aggregationSynchronizer.setElasticSearchAdapter(esAdapter);
 157
 158                 String nodesQueryResponse = TestResourceLoader
 159                                 .getTestResourceDataJson("/sync/aai/activeInventory_complex_nodesQuery_response.json");
 160
 161                 OperationResult complexSelfLinks = new OperationResult();
 162
 163                 complexSelfLinks.setResultCode(200);
 164                 complexSelfLinks.setResult(nodesQueryResponse);
 165
 166                 Mockito.when( aaiAdapter.getSelfLinksByEntityType("complex")).thenReturn(complexSelfLinks);
 167
 168                 for (int x = 1; x <= 5; x++) {
 169
 170                         Mockito.when(aaiAdapter.repairSelfLink(Matchers.contains("complex" + x), Mockito.anyString()))
 171                                         .thenReturn("https://server.proxy:8443/aai/v11/cloud-infrastructure/complexes/complex" + x);
 172
 173                         Mockito.when(aaiAdapter.queryActiveInventoryWithRetries(Matchers.contains("complex" + x),
 174                                         Mockito.anyString(), Mockito.anyInt()))
 175                                         .thenReturn(new OperationResult(200, TestResourceLoader
 176                                                         .getTestResourceDataJson("/sync/aai/complex" + x + "_fullDepth_aaiEntityRetrieval.json")));
 177
 178                 }
 179
 180                 Mockito.when(esAdapter.buildElasticSearchGetDocUrl(Mockito.anyString(), Mockito.anyString())).thenReturn(
 181                                 "http://localhost:9200/myindex/mytype/doc1", "http://localhost:9200/myindex/mytype/doc2",
 182                                 "http://localhost:9200/myindex/mytype/doc3", "http://localhost:9200/myindex/mytype/doc4",
 183                                 "http://localhost:9200/myindex/mytype/doc5");
 184
 185                 /*
 186                  * Our initial gets from elastic search should be record-not-found
 187                  */
 188                 Mockito.when( esAdapter.doGet(Matchers.contains("doc1"), Mockito.any())).thenReturn(new OperationResult(404,null));
 189                 Mockito.when( esAdapter.doGet(Matchers.contains("doc2"), Mockito.any())).thenReturn(new OperationResult(404,null));
 190                 Mockito.when( esAdapter.doGet(Matchers.contains("doc3"), Mockito.any())).thenReturn(new OperationResult(404,null));
 191                 Mockito.when( esAdapter.doGet(Matchers.contains("doc4"), Mockito.any())).thenReturn(new OperationResult(404,null));
 192                 Mockito.when( esAdapter.doGet(Matchers.contains("doc5"), Mockito.any())).thenReturn(new OperationResult(404,null));
 193
 194
 195                 Mockito.when(esAdapter.doPut(Matchers.contains("doc"), Mockito.any(), Mockito.any()))
 196                                 .thenReturn(new OperationResult(200, null));
 197
 198                 OperationState syncState = aggregationSynchronizer.doSync();
 199                 assertEquals(OperationState.OK, syncState);
 200
 201                 assertEquals(SynchronizerState.IDLE, aggregationSynchronizer.getState());
 202                 assertNotNull(aggregationSynchronizer.getStatReport(false));
 203                 assertNotNull(aggregationSynchronizer.getStatReport(true));
 204
 205                 aggregationSynchronizer.clearCache();
 206                 aggregationSynchronizer.shutdown();
 207
 208
 209         }
 210
 211         @Test
 212         public void validateSmallSyncWithRetries() throws Exception {
 213
 214                 aggregationSynchronizer = new AggregationSynchronizer("complex", esSchemaConfig, 5, 5, 5, aaiStatConfig,
 215                                 esStatConfig, oxmEntityLookup);
 216
 217                 aggregationSynchronizer.setAaiAdapter(aaiAdapter);
 218                 aggregationSynchronizer.setElasticSearchAdapter(esAdapter);
 219
 220                 String nodesQueryResponse = TestResourceLoader
 221                                 .getTestResourceDataJson("/sync/aai/activeInventory_complex_nodesQuery_response.json");
 222
 223                 OperationResult complexSelfLinks = new OperationResult();
 224
 225                 complexSelfLinks.setResultCode(200);
 226                 complexSelfLinks.setResult(nodesQueryResponse);
 227
 228                 Mockito.when( aaiAdapter.getSelfLinksByEntityType("complex")).thenReturn(complexSelfLinks);
 229
 230                 for (int x = 1; x <= 5; x++) {
 231
 232                         Mockito.when(aaiAdapter.repairSelfLink(Matchers.contains("complex" + x), Mockito.anyString()))
 233                                         .thenReturn("https://server.proxy:8443/aai/v11/cloud-infrastructure/complexes/complex" + x);
 234
 235                         Mockito.when(aaiAdapter.queryActiveInventoryWithRetries(Matchers.contains("complex" + x),
 236                                         Mockito.anyString(), Mockito.anyInt()))
 237                                         .thenReturn(new OperationResult(200, TestResourceLoader
 238                                                         .getTestResourceDataJson("/sync/aai/complex" + x + "_fullDepth_aaiEntityRetrieval.json")));
 239
 240                 }
 241
 242                 Mockito.when(esAdapter.buildElasticSearchGetDocUrl(Mockito.anyString(), Mockito.anyString())).thenReturn(
 243                                 "http://localhost:9200/myindex/mytype/doc1", "http://localhost:9200/myindex/mytype/doc2",
 244                                 "http://localhost:9200/myindex/mytype/doc3", "http://localhost:9200/myindex/mytype/doc4",
 245                                 "http://localhost:9200/myindex/mytype/doc5");
 246
 247                 /*
 248                  * Our initial gets from elastic search should be record-not-found
 249                  */
 250                 Mockito.when( esAdapter.doGet(Matchers.contains("doc1"), Mockito.any())).thenReturn(new OperationResult(404,null));
 251                 Mockito.when( esAdapter.doGet(Matchers.contains("doc2"), Mockito.any())).thenReturn(new OperationResult(404,null));
 252                 Mockito.when( esAdapter.doGet(Matchers.contains("doc3"), Mockito.any())).thenReturn(new OperationResult(404,null));
 253                 Mockito.when( esAdapter.doGet(Matchers.contains("doc4"), Mockito.any())).thenReturn(new OperationResult(404,null));
 254                 Mockito.when( esAdapter.doGet(Matchers.contains("doc5"), Mockito.any())).thenReturn(new OperationResult(404,null));
 255
 256
 257                 // 409 is the elastic search version conflict code, which will result in the entries being added
 258                 // to our retry queue and re-attempted a couple times.
 259
 260                 Mockito.when(esAdapter.doPut(Matchers.contains("doc"), Mockito.any(), Mockito.any()))
 261                                 .thenReturn(new OperationResult(409, null));
 262
 263                 OperationState syncState = aggregationSynchronizer.doSync();
 264                 assertEquals(OperationState.OK, syncState);
 265
 266                 assertEquals(SynchronizerState.IDLE, aggregationSynchronizer.getState());
 267                 assertNotNull(aggregationSynchronizer.getStatReport(false));
 268                 assertNotNull(aggregationSynchronizer.getStatReport(true));
 269
 270                 aggregationSynchronizer.clearCache();
 271                 aggregationSynchronizer.shutdown();
 272
 273         }
 274
 275         @Test
 276         public void validateSmallSyncWithDocumentElementMerges() throws Exception {
 277
 278                 aggregationSynchronizer = new AggregationSynchronizer("complex", esSchemaConfig, 5, 5, 5, aaiStatConfig,
 279                                 esStatConfig, oxmEntityLookup);
 280
 281                 aggregationSynchronizer.setAaiAdapter(aaiAdapter);
 282                 aggregationSynchronizer.setElasticSearchAdapter(esAdapter);
 283
 284                 String nodesQueryResponse = TestResourceLoader
 285                                 .getTestResourceDataJson("/sync/aai/activeInventory_complex_nodesQuery_response.json");
 286
 287                 OperationResult complexSelfLinks = new OperationResult();
 288
 289                 complexSelfLinks.setResultCode(200);
 290                 complexSelfLinks.setResult(nodesQueryResponse);
 291
 292                 Mockito.when( aaiAdapter.getSelfLinksByEntityType("complex")).thenReturn(complexSelfLinks);
 293
 294                 for (int x = 1; x <= 5; x++) {
 295
 296                         Mockito.when(aaiAdapter.repairSelfLink(Matchers.contains("complex" + x), Mockito.anyString()))
 297                                         .thenReturn("https://server.proxy:8443/aai/v11/cloud-infrastructure/complexes/complex" + x);
 298
 299                         Mockito.when(aaiAdapter.queryActiveInventoryWithRetries(Matchers.contains("complex" + x),
 300                                         Mockito.anyString(), Mockito.anyInt()))
 301                                         .thenReturn(new OperationResult(200, TestResourceLoader
 302                                                         .getTestResourceDataJson("/sync/aai/complex" + x + "_fullDepth_aaiEntityRetrieval.json")));
 303
 304                 }
 305
 306                 Mockito.when(esAdapter.buildElasticSearchGetDocUrl(Mockito.anyString(), Mockito.anyString())).thenReturn(
 307                                 "http://localhost:9200/myindex/mytype/doc1", "http://localhost:9200/myindex/mytype/doc2",
 308                                 "http://localhost:9200/myindex/mytype/doc3", "http://localhost:9200/myindex/mytype/doc4",
 309                                 "http://localhost:9200/myindex/mytype/doc5");
 310
 311                 /*
 312                  * Our initial gets from elastic search return 200 ok with a found entity document requiring a doc update
 313                  */
 314                 Mockito.when(esAdapter.doGet(Matchers.contains("doc1"), Mockito.any())).thenReturn(new OperationResult(200,
 315                                 TestResourceLoader.getTestResourceDataJson("/sync/ElasticSearch/docEntityFromElasticSearch1.json")));
 316
 317                 Mockito.when(esAdapter.doGet(Matchers.contains("doc2"), Mockito.any())).thenReturn(new OperationResult(200,
 318                                 TestResourceLoader.getTestResourceDataJson("/sync/ElasticSearch/docEntityFromElasticSearch2.json")));
 319
 320                 Mockito.when(esAdapter.doGet(Matchers.contains("doc3"), Mockito.any())).thenReturn(new OperationResult(200,
 321                                 TestResourceLoader.getTestResourceDataJson("/sync/ElasticSearch/docEntityFromElasticSearch3.json")));
 322
 323                 Mockito.when(esAdapter.doGet(Matchers.contains("doc4"), Mockito.any())).thenReturn(new OperationResult(200,
 324                                 TestResourceLoader.getTestResourceDataJson("/sync/ElasticSearch/docEntityFromElasticSearch4.json")));
 325
 326                 Mockito.when(esAdapter.doGet(Matchers.contains("doc5"), Mockito.any())).thenReturn(new OperationResult(200,
 327                                 TestResourceLoader.getTestResourceDataJson("/sync/ElasticSearch/docEntityFromElasticSearch5.json")));
 328
 329                 Mockito.when(esAdapter.doPut(Matchers.contains("doc"), Mockito.any(), Mockito.any()))
 330                                 .thenReturn(new OperationResult(200, null));
 331
 332                 OperationState syncState = aggregationSynchronizer.doSync();
 333                 assertEquals(OperationState.OK, syncState);
 334
 335                 assertEquals(SynchronizerState.IDLE, aggregationSynchronizer.getState());
 336                 assertNotNull(aggregationSynchronizer.getStatReport(false));
 337                 assertNotNull(aggregationSynchronizer.getStatReport(true));
 338
 339                 aggregationSynchronizer.clearCache();
 340                 aggregationSynchronizer.shutdown();
 341
 342
 343         }
 344
 345 }