2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
20 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
22 package org.onap.aai.dbgraphgen;
24 import static org.junit.Assert.assertEquals;
25 import static org.junit.Assert.assertNotNull;
26 import static org.junit.Assert.assertTrue;
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;
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;
63 @RunWith(MockitoJUnitRunner.class)
64 public class ModelBasedProcessingTest {
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;
72 private DbMethHelper dbMethHelper;
75 public static void configure() throws Exception {
76 System.setProperty("AJSC_HOME", ".");
77 System.setProperty("BUNDLECONFIG_DIR", "src/main/resources");
78 loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST);
84 mockProcessor = new ModelBasedProcessing(loader, dbEngine, serializer);
86 MockitoAnnotations.initMocks(this);
90 public void testPropNameChange1() throws AAIUnknownObjectException {
92 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
93 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "model-invariant-id");
94 assertEquals("result has -local tacked on the end as it should", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX, result);
95 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "vnf-id");
96 assertEquals("result does NOT have -local tacked on the end as it should", "vnf-id", result);
97 result = processor.getPropNameWithAliasIfNeeded("generic-vnf", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX);
98 assertEquals("property not modified because it already includes the right suffix", "model-invariant-id" + AAIProperties.DB_ALIAS_SUFFIX, result);
102 GraphTraversal<Vertex, Vertex> v;
104 GraphTraversal<Vertex, Vertex> graphTraversal;
106 GraphTraversalSource graphTraversalSource;
107 @Mock Iterable <?> uniqVerts;
108 List<Vertex> vertexList=new ArrayList<>();
110 @Mock Vertex vertex1;
112 QueryBuilder<Vertex> queryBuilder;
115 @Test(expected = NullPointerException.class)
116 public void getStartNodesAndModVersionIds() throws AAIException{
118 vertex.property("model-ver","model-version-id");
119 vertex1.property(AAIProperties.NODE_TYPE,"model-ver");
120 graphTraversal.addV(vertex);
122 vertexList.add(vertex);
123 //vertexList.add(vertex1);
124 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
125 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
126 Mockito.when(graphTraversalSource.V()).thenReturn(v);
127 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
128 Mockito.when(graphTraversal.has("model-ver","model-version-id")).thenReturn(graphTraversal);
129 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
130 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
131 //this.engine.getQueryBuilder(startV).createEdgeTraversal(treeType, startV, loader.introspectorFromName(connectedNodeType));
133 queryBuilder.toList().add(vertex);
134 Mockito.when(dbEngine.getQueryBuilder(vertex)).thenReturn(queryBuilder);
136 Introspector obj=loader.introspectorFromName("model-ver");
138 Mockito.when(queryBuilder.createEdgeTraversal(EdgeType.TREE,vertex,obj)).thenReturn(queryBuilder);
139 //Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","model-ver","model-version-id","vnf-id-1");
142 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
144 Map<String,String> result1=processor.getStartNodesAndModVersionIds("9999","postmen","vnf-id-1","vnf-id-1",
145 "vnf-id","generic-vnf",startNodeFilterArrayOfHashes,"");
149 @Test(expected = AAIException.class)
150 public void getStartNodesAndModVersionIds1() throws AAIException{
152 vertex.property("model-version-id","vnf-id-1");
153 vertex1.property(AAIProperties.NODE_TYPE,"model-ver");
154 graphTraversal.addV(vertex);
156 vertexList.add(vertex);
157 //vertexList.add(vertex1);
158 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
159 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
160 Mockito.when(graphTraversalSource.V()).thenReturn(v);
161 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
162 Mockito.when(graphTraversal.has("model-version-id","vnf-id-1")).thenReturn(graphTraversal);
163 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
164 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
165 //this.engine.getQueryBuilder(startV).createEdgeTraversal(treeType, startV, loader.introspectorFromName(connectedNodeType));
167 queryBuilder.toList().add(vertex);
168 Mockito.when(dbEngine.getQueryBuilder(vertex)).thenReturn(queryBuilder);
170 Introspector obj=loader.introspectorFromName("generic-vnf");
171 Mockito.when(queryBuilder.createEdgeTraversal(EdgeType.TREE,vertex,obj)).thenReturn(queryBuilder);
172 //Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","model-ver","model-version-id","vnf-id-1");
175 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
177 Map<String,String> result1=processor.getStartNodesAndModVersionIds("9999","postmen","vnf-id-1","vnf-id-1",
178 "vnf-id","generic-vnf",startNodeFilterArrayOfHashes,"");
182 public void getNodeUsingUniqueIdTest() throws AAIException{
183 vertex.property("vnf-id","vnf-id-1");
184 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
185 graphTraversal.addV(vertex);
187 vertexList.add(vertex);
188 //vertexList.add(vertex1);
189 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
190 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
191 Mockito.when(graphTraversalSource.V()).thenReturn(v);
192 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
193 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
194 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
195 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
197 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
199 assertNotNull(result);
203 public void getNodeUsingUniqueIdTest1() throws AAIException{
204 vertex.property("named-query-uui","vnf-id-1");
205 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
206 graphTraversal.addV(vertex);
208 vertexList.add(vertex);
209 //vertexList.add(vertex1);
210 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
211 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
212 Mockito.when(graphTraversalSource.V()).thenReturn(v);
213 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
214 Mockito.when(graphTraversal.has("named-query-uui","vnf-id-1")).thenReturn(graphTraversal);
215 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
216 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
218 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","named-query","named-query-uui","vnf-id-1");
220 assertNotNull(result);
223 @Test(expected = AAIException.class)
224 public void getModelVersUsingNameTest() throws AAIException{
226 vertex.property(AAIProperties.NODE_TYPE,"generic-vnf");
227 vertex1.property("generic-vnf","generic-vnf");
228 graphTraversal.addV(vertex1);
230 vertexList.add(vertex);
231 vertexList.add(vertex1);
232 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
233 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
234 Mockito.when(graphTraversalSource.V()).thenReturn(v);
235 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-ver")).thenReturn(graphTraversal);
236 Mockito.when(graphTraversal.has("model-name","generic-vnf")).thenReturn(graphTraversal);
237 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
238 //Mockito.when(vertexList.listIterator().hasNext()).thenReturn(true);
239 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
241 List<Vertex> result=processor.getModelVersUsingName("9999","postment","generic-vnf");
243 assertTrue(result.size()>0);
246 //uniqueIdVal Null Expecting AAI Excpetion
247 @Test(expected = AAIException.class)
248 public void getNodeUsingUniqueIdTestNull() throws AAIException{
249 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
250 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","");
255 //idPropertyName Null Expecting AAI Excpetion
256 @Test(expected = AAIException.class)
257 public void getNodeUsingUniqueIdTestNull1() throws AAIException{
258 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
259 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","","vnf-id-1");
264 //idPropertyName Null Expecting AAI Excpetion
265 @Test(expected = AAIException.class)
266 public void getNodeUsingUniqueIdTestNull2() throws AAIException{
267 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
268 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","","vnf-id","vnf-id-1");
273 @Test(expected = AAIException.class)
274 public void getNodeUsingUniqueIdTestTwoVertex() throws AAIException{
275 vertex.property("vnf-id","vnf-id-1");
276 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
277 graphTraversal.addV(vertex);
279 vertexList.add(vertex);
280 vertexList.add(vertex1);
281 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
282 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
283 Mockito.when(graphTraversalSource.V()).thenReturn(v);
284 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
285 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
286 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
287 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
289 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
291 assertNotNull(result);
294 //uniqVerts Null Expection AAI Exception
295 @Test(expected = AAIException.class)
296 public void getNodeUsingUniqueIdTestVertexNull() throws AAIException{
297 vertex.property("vnf-id","vnf-id-1");
298 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
299 graphTraversal.addV(vertex);
301 vertexList.add(vertex);
302 //vertexList.add(vertex1);
303 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
304 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
305 Mockito.when(graphTraversalSource.V()).thenReturn(v);
306 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
307 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
308 Mockito.when(graphTraversal.toList()).thenReturn(null);
309 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
311 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
313 assertNotNull(result);
316 //uniqVerts Null Expection AAI Exception
317 @Test(expected = AAIException.class)
318 public void getNodeUsingUniqueIdTestVertexHasNot() throws AAIException{
319 vertex.property("vnf-id","vnf-id-1");
320 vertex1.property(AAIProperties.NODE_TYPE,"generic-vnf");
321 graphTraversal.addV(vertex);
323 //vertexList.add(vertex);
324 //vertexList.add(vertex1);
325 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
326 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
327 Mockito.when(graphTraversalSource.V()).thenReturn(v);
328 Mockito.when(v.has(AAIProperties.NODE_TYPE,"generic-vnf")).thenReturn(graphTraversal);
329 Mockito.when(graphTraversal.has("vnf-id","vnf-id-1")).thenReturn(graphTraversal);
330 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
331 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
333 Vertex result=processor.getNodeUsingUniqueId("9999", "postmen","generic-vnf","vnf-id","vnf-id-1");
335 assertNotNull(result);
338 @Test(expected = AAIIdentityMapParseException.class)
339 public void runDeleteByModelTest() throws AAIException{
340 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
341 Optional<Vertex> vertex=Optional.empty();
342 Map<String,Object> startNodeFilterHash=new HashMap<>();
343 startNodeFilterHash.put("related-link.data","relationshipdata");
344 startNodeFilterHash.put("generic-vnf.d","relationshipdata");
345 Mockito.when(dbMethHelper.searchVertexByIdentityMap("relationship-data",startNodeFilterHash)).thenReturn(vertex);
346 Map<String,String> re =processor.runDeleteByModel("9999","postmen","","relationship-data",startNodeFilterHash,"vnf-id","vnf-id");
352 @Test(expected = AAIException.class)
353 public void getModelGivenModelVerTest() throws AAIException{
354 vertex.property("named-query-uuid","vnf-id-1");
355 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
356 graphTraversal.addV(vertex);
358 vertexList.add(vertex);
359 //vertexList.add(vertex1);
360 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
361 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
362 Mockito.when(graphTraversalSource.V()).thenReturn(v);
363 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
364 Mockito.when(graphTraversal.has("named-query-uuid","vnf-id-1")).thenReturn(graphTraversal);
365 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
367 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
368 qub.toList().addAll(vertexList);
369 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
371 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
373 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
375 Vertex result=processor.getModelGivenModelVer(vertex,"");
376 assertNotNull(result);
380 @Test(expected = AAIException.class)
381 public void queryByNamedQuery_TimedTest() throws AAIException{
382 vertex.property("named-query-uuid","named-query-element");
383 vertex1.property(AAIProperties.NODE_TYPE,"named-query");
384 graphTraversal.addV(vertex);
386 vertexList.add(vertex);
387 //vertexList.add(vertex1);
388 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
389 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
390 Mockito.when(graphTraversalSource.V()).thenReturn(v);
391 Mockito.when(v.has(AAIProperties.NODE_TYPE,"named-query")).thenReturn(graphTraversal);
392 Mockito.when(graphTraversal.has("named-query-uuid","named-query-element")).thenReturn(graphTraversal);
393 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
395 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
396 qub.toList().addAll(vertexList);
397 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
399 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
401 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
403 List<Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<>();
404 Map<String,Object> secondaryFilterHash=new HashMap<>();
406 List<ResultSet> res=processor.queryByNamedQuery_Timed("99999","postmen","named-query-element",startNodeFilterArrayOfHashes,"vnf","vnf",
407 secondaryFilterHash);
412 @Test(expected = AAIException.class)
413 public void genTopoMap4NamedQTest() throws AAIException{
414 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
416 vertex.property("named-query-uuid","named-query-element");
417 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
418 graphTraversal.addV(vertex);
420 vertexList.add(vertex);
421 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
422 qub.toList().addAll(vertexList);
423 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
425 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
427 Multimap<String, String> map =processor.genTopoMap4NamedQ("9999","postmen",vertex,"named-query-element");
430 @Test(expected = AAIException.class)
431 public void genTopoMap4NamedQTest1() throws AAIException{
432 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
434 vertex.property("named-query-uuid","named-query-element");
435 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
436 graphTraversal.addV(vertex);
438 vertexList.add(vertex);
439 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
440 qub.toList().addAll(vertexList);
441 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
443 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
445 Multimap<String, String> map =processor.genTopoMap4NamedQ("9999","postmen",null,"named-query-element");
448 @Test(expected = AAIException.class)
449 public void getModelThatNqElementRepresentsTest() throws AAIException{
450 vertex.property("model-ver","named-query-element");
451 vertex1.property(AAIProperties.NODE_TYPE,"named-query-element");
452 graphTraversal.addV(vertex);
454 vertexList.add(vertex);
455 QueryBuilder qub=Mockito.mock(QueryBuilder.class);
456 qub.toList().addAll(vertexList);
457 Mockito.when(dbEngine.getQueryBuilder(Mockito.any(Vertex.class))).thenReturn(queryBuilder);
459 Mockito.when(queryBuilder.createEdgeTraversal(Mockito.any(EdgeType.class),Mockito.any(Vertex.class),Mockito.any(Introspector.class))).thenReturn(qub);
460 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
461 Vertex v=processor.getModelThatNqElementRepresents(vertex,"g");
464 @Test(expected = NullPointerException.class)
465 public void getModelTypeFromModel() throws AAIException{
466 Vertex vt=Mockito.mock(Vertex.class);
467 vt.property("model-type","named-query-element");
468 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
469 String v=processor.getModelTypeFromModel(vt,"g");
472 @Test(expected = AAIException.class)
473 public void getModelTypeFromModel1() throws AAIException{
474 Vertex vt=Mockito.mock(Vertex.class);
475 vt.property("model-type","named-query-element");
476 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
477 String v=processor.getModelTypeFromModel(null,"g");
480 @Test(expected = NullPointerException.class)
481 public void getModVersUsingModelInvId() throws AAIException{
483 vertex.property(AAIProperties.NODE_TYPE,"model-invariant-id");
484 vertex1.property("model","model-invariant-id");
485 graphTraversal.addV(vertex1);
487 vertexList.add(vertex);
488 vertexList.add(vertex1);
489 Mockito.when(dbEngine.asAdmin()).thenReturn(admin);
490 Mockito.when(admin.getReadOnlyTraversalSource()).thenReturn(graphTraversalSource);
491 Mockito.when(graphTraversalSource.V()).thenReturn(v);
492 Mockito.when(v.has(AAIProperties.NODE_TYPE,"model-invariant-id")).thenReturn(graphTraversal);
493 Mockito.when(graphTraversal.has("model","model-invariant-id")).thenReturn(graphTraversal);
494 Mockito.when(graphTraversal.toList()).thenReturn(vertexList);
495 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
497 Iterator<Vertex> result=processor.getModVersUsingModelInvId("9999","postment","model");
500 @Test(expected = AAIException.class)
501 public void getNamedQueryExtraDataLookupTest() throws AAIException{
502 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
504 Map<String,Object> re=processor.getNamedQueryExtraDataLookup("","",null,vertex,
508 @Test(expected = AAIException.class)
509 public void getNamedQueryExtraDataLookupTest1() throws AAIException{
510 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
512 Map<String,Object> re=processor.getNamedQueryExtraDataLookup("","",vertex,null,
516 @Test(expected = NullPointerException.class)
517 public void showResultSet() throws AAIException{
518 vertex.property("model-ver","model-versionId");
519 vertex.property("aai","model-versionId");
522 ResultSet rs= Mockito.mock(ResultSet.class);
523 Mockito.when(rs.getVert()).thenReturn(vertex);
525 List<VertexProperty<String>> vb=new ArrayList<>();
526 VertexProperty<String> v=Mockito.mock(VertexProperty.class);
527 v.property("model-ver","1");
529 v.property("aai","5");
531 v.property("source-of-truth","6");
534 vertex.properties("model-ver","aai");
535 Mockito.when(vertex.<String>property(AAIProperties.NODE_TYPE)).thenReturn(v);
536 //Mockito.when(vertex.properties()).thenReturn(Mockito.any());
537 ModelBasedProcessing processor = new ModelBasedProcessing(loader, dbEngine, serializer);
538 processor.showResultSet(rs,8);