aai-traversal/src/test/java/org/onap/aai/dbgraphgen/ModelBasedProcessingTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  *
  20  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  */
  22 package org.onap.aai.dbgraphgen;
  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 com.bazaarvoice.jolt.modifier.DataType;
  29 import com.google.common.collect.Multimap;
  30 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  31 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  32 import org.apache.tinkerpop.gremlin.structure.Vertex;
  33 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
  34 import org.junit.Before;
  35 import org.junit.BeforeClass;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.*;
  39 import org.mockito.internal.exceptions.MockitoLimitations;
  40 import org.mockito.runners.MockitoJUnitRunner;
  41 import org.onap.aai.db.DbMethHelper;
  42 import org.onap.aai.db.props.AAIProperties;
  43 import org.onap.aai.exceptions.AAIException;
  44 import org.onap.aai.introspection.Introspector;
  45 import org.onap.aai.introspection.Loader;
  46 import org.onap.aai.introspection.LoaderFactory;
  47 import org.onap.aai.introspection.ModelType;
  48 import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
  49 import org.onap.aai.parsers.exceptions.AAIIdentityMapParseException;
  50 import org.onap.aai.query.builder.GraphTraversalBuilder;
  51 import org.onap.aai.query.builder.QueryBuilder;
  52 import org.onap.aai.query.builder.TraversalQuery;
  53 import org.onap.aai.schema.enums.PropertyMetadata;
  54 import org.onap.aai.serialization.db.DBSerializer;
  55 import org.onap.aai.serialization.db.EdgeType;
  56 import org.onap.aai.serialization.engines.QueryStyle;
  57 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  58 import org.powermock.modules.junit4.PowerMockRunner;
  59 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  60
  61 import java.util.*;
  62
  63 @RunWith(MockitoJUnitRunner.class)
  64 public class ModelBasedProcessingTest {
  65
  66         @Mock private static TransactionalGraphEngine dbEngine;
  67         private static Loader loader;
  68         @Mock private static DBSerializer serializer;
  69         @Mock private static TransactionalGraphEngine.Admin admin;
  70         ModelBasedProcessing mockProcessor;
  71         @Mock
  72         private DbMethHelper dbMethHelper;
  73
  74         @BeforeClass
  75         public static void configure() throws Exception {
  76                 System.setProperty("AJSC_HOME", ".");
  77                 System.setProperty("BUNDLECONFIG_DIR", "bundleconfig-local");
  78                 loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST);
  79
  80
  81         }
  82
  83         @Before
  84         public void init() {
  85                 mockProcessor = new ModelBasedProcessing(loader, dbEngine, serializer);
  86
  87                 MockitoAnnotations.initMocks(this);
  88         }
  89
  90         @Test
  91         public void testPropNameChange1() throws AAIUnknownObjectException {
  92                 String result;
  93                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
  94                 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "model-invariant-id");
  95                 assertEquals("result has -local tacked on the end as it should", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX, result);
  96                 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "vnf-id");
  97                 assertEquals("result does NOT have -local tacked on the end as it should", "vnf-id", result);
  98                 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX);
  99                 assertEquals("property not modified because it already includes the right suffix", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX, result);
 100         }
 101
 102         @Mock
 103         GraphTraversal<Vertex, Vertex> v;
 104         @Mock
 105         GraphTraversal<Vertex, Vertex> graphTraversal;
 106         @Mock
 107         GraphTraversalSource graphTraversalSource;
 108         @Mock Iterable <?> uniqVerts;
 109         List<Vertex> vertexList=new ArrayList<>();
 110         @Mock Vertex vertex;
 111         @Mock Vertex vertex1;
 112         @Mock
 113         QueryBuilder<Vertex> queryBuilder;
 114
 115         EdgeType treeType;
 116         @Test(expected = NullPointerException.class)
 117         public void getStartNodesAndModVersionIds() throws AAIException{
 118
 119                 vertex.property("model-ver","model-version-id");
 120                 vertex1.property(AAIProperties.NODE_TYPE,"model-ver");
 121                 graphTraversal.addV(vertex);
 122                 v.addV(vertex1);
 123                 vertexList.add(vertex);
 124                 //vertexList.add(vertex1);
 125                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 126                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 127                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 128                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
 129                 Mockito.when(graphTraversal.has("model-ver","model-version-id")).thenReturn(graphTraversal);
 130                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 131                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 132                 //this.engine.getQueryBuilder(startV).createEdgeTraversal(treeType, startV, loader.introspectorFromName(connectedNodeType));
 133
 134                 queryBuilder.toList().add(vertex);
 135                 Mockito.when(dbEngine.getQueryBuilder(vertex)).thenReturn(queryBuilder);
 136
 137                 Introspector obj=loader.introspectorFromName("model-ver");
 138
 139                 Mockito.when(queryBuilder.createEdgeTraversal(EdgeType.TREE,vertex,obj)).thenReturn(queryBuilder);
 140                 //Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","model-ver","model-version-id","vnf-id-1");
 141
 142
 143                 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
 144
 145                 Map<String,String> result1=processor.getStartNodesAndModVersionIds("9999","postmen","vnf-id-1","vnf-id-1",
 146                                 "vnf-id","generic-vnf",startNodeFilterArrayOfHashes,"");
 147         }
 148
 149
 150         @Test(expected = AAIException.class)
 151         public void getStartNodesAndModVersionIds1() throws AAIException{
 152
 153                 vertex.property("model-version-id","vnf-id-1");
 154                 vertex1.property(AAIProperties.NODE_TYPE,"model-ver");
 155                 graphTraversal.addV(vertex);
 156                 v.addV(vertex1);
 157                 vertexList.add(vertex);
 158                 //vertexList.add(vertex1);
 159                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 160                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 161                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 162                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
 163                 Mockito.when(graphTraversal.has("model-version-id","vnf-id-1")).thenReturn(graphTraversal);
 164                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 165                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 166                 //this.engine.getQueryBuilder(startV).createEdgeTraversal(treeType, startV, loader.introspectorFromName(connectedNodeType));
 167
 168                 queryBuilder.toList().add(vertex);
 169                 Mockito.when(dbEngine.getQueryBuilder(vertex)).thenReturn(queryBuilder);
 170
 171                 Introspector obj=loader.introspectorFromName("generic-vnf");
 172                 Mockito.when(queryBuilder.createEdgeTraversal(EdgeType.TREE,vertex,obj)).thenReturn(queryBuilder);
 173                 //Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","model-ver","model-version-id","vnf-id-1");
 174
 175
 176                 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
 177
 178                 Map<String,String> result1=processor.getStartNodesAndModVersionIds("9999","postmen","vnf-id-1","vnf-id-1",
 179                                 "vnf-id","generic-vnf",startNodeFilterArrayOfHashes,"");
 180         }
 181
 182         @Test
 183         public void  getNodeUsingUniqueIdTest() throws AAIException{
 184                 vertex.property("vnf-id","vnf-id-1");
 185                 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
 186                 graphTraversal.addV(vertex);
 187                 v.addV(vertex1);
 188                 vertexList.add(vertex);
 189                 //vertexList.add(vertex1);
 190                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 191                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 192                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 193                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
 194                 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
 195                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 196                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 197
 198                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
 199
 200                 assertNotNull(result);
 201         }
 202
 203         @Test
 204         public void  getNodeUsingUniqueIdTest1() throws AAIException{
 205                 vertex.property("named-query-uui","vnf-id-1");
 206                 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
 207                 graphTraversal.addV(vertex);
 208                 v.addV(vertex1);
 209                 vertexList.add(vertex);
 210                 //vertexList.add(vertex1);
 211                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 212                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 213                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 214                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
 215                 Mockito.when(graphTraversal.has("named-query-uui","vnf-id-1")).thenReturn(graphTraversal);
 216                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 217                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 218
 219                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","named-query","named-query-uui","vnf-id-1");
 220
 221                 assertNotNull(result);
 222         }
 223
 224         @Test(expected = AAIException.class)
 225         public void getModelVersUsingNameTest() throws  AAIException{
 226
 227                 vertex.property(AAIProperties.NODE_TYPE,"generic-vnf");
 228                 vertex1.property("generic-vnf","generic-vnf");
 229                 graphTraversal.addV(vertex1);
 230                 v.addV(vertex1);
 231                 vertexList.add(vertex);
 232                 vertexList.add(vertex1);
 233                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 234                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 235                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 236                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
 237                 Mockito.when(graphTraversal.has("model-name","generic-vnf")).thenReturn(graphTraversal);
 238                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 239                 //Mockito.when(vertexList.listIterator().hasNext()).thenReturn(true);
 240                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 241
 242                 List<Vertex> result=processor.getModelVersUsingName("9999","postment","generic-vnf");
 243
 244                 assertTrue(result.size()>0);
 245         }
 246
 247         //uniqueIdVal  Null Expecting AAI Excpetion
 248         @Test(expected = AAIException.class)
 249         public void  getNodeUsingUniqueIdTestNull() throws AAIException{
 250                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 251                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","");
 252
 253
 254         }
 255
 256         //idPropertyName   Null Expecting AAI Excpetion
 257         @Test(expected = AAIException.class)
 258         public void  getNodeUsingUniqueIdTestNull1() throws AAIException{
 259                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 260                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","","vnf-id-1");
 261
 262
 263         }
 264
 265         //idPropertyName   Null Expecting AAI Excpetion
 266         @Test(expected = AAIException.class)
 267         public void  getNodeUsingUniqueIdTestNull2() throws AAIException{
 268                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 269                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","","vnf-id","vnf-id-1");
 270
 271
 272         }
 273
 274         @Test(expected = AAIException.class)
 275         public void  getNodeUsingUniqueIdTestTwoVertex() throws AAIException{
 276                 vertex.property("vnf-id","vnf-id-1");
 277                 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
 278                 graphTraversal.addV(vertex);
 279                 v.addV(vertex1);
 280                 vertexList.add(vertex);
 281                 vertexList.add(vertex1);
 282                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 283                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 284                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 285                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
 286                 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
 287                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 288                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 289
 290                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
 291
 292                 assertNotNull(result);
 293         }
 294
 295         //uniqVerts Null Expection AAI Exception
 296         @Test(expected = AAIException.class)
 297         public void  getNodeUsingUniqueIdTestVertexNull() throws AAIException{
 298                 vertex.property("vnf-id","vnf-id-1");
 299                 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
 300                 graphTraversal.addV(vertex);
 301                 v.addV(vertex1);
 302                 vertexList.add(vertex);
 303                 //vertexList.add(vertex1);
 304                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 305                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 306                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 307                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
 308                 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
 309                 Mockito.when(graphTraversal.toList()).thenReturn(null);
 310                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 311
 312                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
 313
 314                 assertNotNull(result);
 315         }
 316
 317         //uniqVerts Null Expection AAI Exception
 318         @Test(expected = AAIException.class)
 319         public void  getNodeUsingUniqueIdTestVertexHasNot() throws AAIException{
 320                 vertex.property("vnf-id","vnf-id-1");
 321                 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
 322                 graphTraversal.addV(vertex);
 323                 v.addV(vertex1);
 324                 //vertexList.add(vertex);
 325                 //vertexList.add(vertex1);
 326                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 327                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 328                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 329                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
 330                 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
 331                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 332                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 333
 334                 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
 335
 336                 assertNotNull(result);
 337         }
 338
 339         @Test(expected = AAIIdentityMapParseException.class)
 340         public  void runDeleteByModelTest() throws  AAIException{
 341                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 342                 Optional<Vertex> vertex=Optional.empty();
 343                 Map<String,Object> startNodeFilterHash=new HashMap<>();
 344                 startNodeFilterHash.put("related-link.data","relationshipdata");
 345                 startNodeFilterHash.put("generic-vnf.d","relationshipdata");
 346                 Mockito.when(dbMethHelper.searchVertexByIdentityMap("relationship-data",startNodeFilterHash)).thenReturn(vertex);
 347                 Map<String,String> re   =processor.runDeleteByModel("9999","postmen","","relationship-data",startNodeFilterHash,"vnf-id","vnf-id");
 348                 assertNotNull(re);
 349
 350
 351         }
 352
 353         @Test(expected = AAIException.class)
 354         public void getModelGivenModelVerTest() throws AAIException{
 355                 vertex.property("named-query-uuid","vnf-id-1");
 356                 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
 357                 graphTraversal.addV(vertex);
 358                 v.addV(vertex1);
 359                 vertexList.add(vertex);
 360                 //vertexList.add(vertex1);
 361                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 362                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 363                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 364                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
 365                 Mockito.when(graphTraversal.has("named-query-uuid","vnf-id-1")).thenReturn(graphTraversal);
 366                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 367
 368                 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
 369                 qub.toList().addAll(vertexList);
 370                 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
 371
 372                 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
 373
 374                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 375
 376                 Vertex result=processor.getModelGivenModelVer(vertex,"");
 377                 assertNotNull(result);
 378
 379         }
 380
 381         @Test(expected = AAIException.class)
 382         public void queryByNamedQuery_TimedTest() throws  AAIException{
 383                 vertex.property("named-query-uuid","named-query-element");
 384                 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
 385                 graphTraversal.addV(vertex);
 386                 v.addV(vertex1);
 387                 vertexList.add(vertex);
 388                 //vertexList.add(vertex1);
 389                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 390                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 391                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 392                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
 393                 Mockito.when(graphTraversal.has("named-query-uuid","named-query-element")).thenReturn(graphTraversal);
 394                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 395
 396                 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
 397                 qub.toList().addAll(vertexList);
 398                 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
 399
 400                 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
 401
 402                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 403
 404                 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
 405                 Map<String,Object> secondaryFilterHash=new HashMap<>();
 406
 407                 List<ResultSet>  res=processor.queryByNamedQuery_Timed("99999","postmen","named-query-element",startNodeFilterArrayOfHashes,"vnf","vnf",
 408                                 secondaryFilterHash);
 409
 410
 411         }
 412
 413         @Test(expected = AAIException.class)
 414         public void genTopoMap4NamedQTest() throws  AAIException{
 415                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 416
 417                 vertex.property("named-query-uuid","named-query-element");
 418                 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
 419                 graphTraversal.addV(vertex);
 420                 v.addV(vertex1);
 421                 vertexList.add(vertex);
 422                 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
 423                 qub.toList().addAll(vertexList);
 424                 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
 425
 426                 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
 427
 428                 Multimap<String, String> map =processor.genTopoMap4NamedQ("9999","postmen",vertex,"named-query-element");
 429         }
 430
 431         @Test(expected = AAIException.class)
 432         public void genTopoMap4NamedQTest1() throws  AAIException{
 433                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 434
 435                 vertex.property("named-query-uuid","named-query-element");
 436                 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
 437                 graphTraversal.addV(vertex);
 438                 v.addV(vertex1);
 439                 vertexList.add(vertex);
 440                 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
 441                 qub.toList().addAll(vertexList);
 442                 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
 443
 444                 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
 445
 446                 Multimap<String, String> map =processor.genTopoMap4NamedQ("9999","postmen",null,"named-query-element");
 447         }
 448
 449         @Test(expected = AAIException.class)
 450         public void getModelThatNqElementRepresentsTest() throws  AAIException{
 451                 vertex.property("model-ver","named-query-element");
 452                 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
 453                 graphTraversal.addV(vertex);
 454                 v.addV(vertex1);
 455                 vertexList.add(vertex);
 456                 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
 457                 qub.toList().addAll(vertexList);
 458                 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
 459
 460                 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
 461                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 462                 Vertex  v=processor.getModelThatNqElementRepresents(vertex,"g");
 463         }
 464
 465         @Test(expected = NullPointerException.class)
 466         public void getModelTypeFromModel() throws  AAIException{
 467                 Vertex vt=Mockito.mock(Vertex.class);
 468                 vt.property("model-type","named-query-element");
 469                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 470                 String  v=processor.getModelTypeFromModel(vt,"g");
 471         }
 472
 473         @Test(expected = AAIException.class)
 474         public void getModelTypeFromModel1() throws  AAIException{
 475                 Vertex vt=Mockito.mock(Vertex.class);
 476                 vt.property("model-type","named-query-element");
 477                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 478                 String  v=processor.getModelTypeFromModel(null,"g");
 479         }
 480
 481         @Test(expected = NullPointerException.class)
 482         public void getModVersUsingModelInvId() throws  AAIException{
 483
 484                 vertex.property(AAIProperties.NODE_TYPE,"model-invariant-id");
 485                 vertex1.property("model","model-invariant-id");
 486                 graphTraversal.addV(vertex1);
 487                 v.addV(vertex1);
 488                 vertexList.add(vertex);
 489                 vertexList.add(vertex1);
 490                 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
 491                 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
 492                 Mockito.when(graphTraversalSource.V()).thenReturn(v);
 493                 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-invariant-id")).thenReturn(graphTraversal);
 494                 Mockito.when(graphTraversal.has("model","model-invariant-id")).thenReturn(graphTraversal);
 495                 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
 496                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 497
 498                 Iterator<Vertex> result=processor.getModVersUsingModelInvId("9999","postment","model");
 499         }
 500
 501         @Test(expected = AAIException.class)
 502         public void getNamedQueryExtraDataLookupTest() throws AAIException{
 503                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 504
 505                 Map<String,Object>  re=processor.getNamedQueryExtraDataLookup("","",null,vertex,
 506                                 "");
 507         }
 508
 509         @Test(expected = AAIException.class)
 510         public void getNamedQueryExtraDataLookupTest1() throws AAIException{
 511                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 512
 513                 Map<String,Object>  re=processor.getNamedQueryExtraDataLookup("","",vertex,null,
 514                                 "");
 515         }
 516
 517         @Test(expected = NullPointerException.class)
 518         public  void showResultSet() throws  AAIException{
 519                 vertex.property("model-ver","model-versionId");
 520                 vertex.property("aai","model-versionId");
 521
 522
 523                 ResultSet rs= Mockito.mock(ResultSet.class);
 524                 Mockito.when(rs.getVert()).thenReturn(vertex);
 525
 526                 List<VertexProperty<String>> vb=new ArrayList<>();
 527                 VertexProperty<String> v=Mockito.mock(VertexProperty.class);
 528                 v.property("model-ver","1");
 529                 vb.add(v);
 530                 v.property("aai","5");
 531                 vb.add(v);
 532                 v.property("source-of-truth","6");
 533                 vb.add(v);
 534
 535                 vertex.properties("model-ver","aai");
 536                 Mockito.when(vertex.<String>property(AAIProperties.NODE_TYPE)).thenReturn(v);
 537                 //Mockito.when(vertex.properties()).thenReturn(Mockito.any());
 538                 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
 539                 processor.showResultSet(rs,8);
 540
 541         }
 542 }