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

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