aai-traversal/src/test/java/org/onap/aai/dbgraphgen/ModelBasedProcessingInvalidDataTest.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.*;
  23 import static org.mockito.Matchers.any;
  24 import static org.mockito.Matchers.anyMap;
  25 import static org.mockito.Matchers.anyMapOf;
  26 import static org.mockito.Mockito.*;
  27
  28 import com.bazaarvoice.jolt.modifier.DataType;
  29 import com.google.common.collect.ArrayListMultimap;
  30 import com.google.common.collect.LinkedListMultimap;
  31 import com.google.common.collect.Multimap;
  32 import com.thinkaurelius.titan.graphdb.olap.computer.VertexMapJob;
  33 import com.thinkaurelius.titan.graphdb.types.VertexLabelVertex;
  34 import com.thinkaurelius.titan.graphdb.types.system.BaseVertexLabel;
  35 import com.thinkaurelius.titan.graphdb.types.system.EmptyVertex;
  36 import com.thinkaurelius.titan.graphdb.types.vertices.EdgeLabelVertex;
  37 import com.thinkaurelius.titan.graphdb.types.vertices.PropertyKeyVertex;
  38 import org.apache.commons.lang.ObjectUtils;
  39 import org.apache.tinkerpop.gremlin.structure.Graph;
  40 import org.apache.tinkerpop.gremlin.structure.T;
  41 import org.apache.tinkerpop.gremlin.structure.Vertex;
  42 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
  43 import org.junit.Before;
  44 import org.junit.BeforeClass;
  45 import org.junit.Test;
  46 import org.junit.runner.RunWith;
  47 import org.mockito.*;
  48 import org.mockito.runners.MockitoJUnitRunner;
  49 import org.onap.aai.db.DbMethHelper;
  50 import org.onap.aai.db.props.AAIProperties;
  51 import org.onap.aai.exceptions.AAIException;
  52 import org.onap.aai.introspection.Loader;
  53 import org.onap.aai.introspection.LoaderFactory;
  54 import org.onap.aai.introspection.ModelType;
  55 import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
  56 import org.onap.aai.serialization.db.DBSerializer;
  57 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  58
  59 import javax.inject.Inject;
  60 import java.util.*;
  61 @RunWith(MockitoJUnitRunner.class)
  62 public class ModelBasedProcessingInvalidDataTest {
  63
  64         @Mock
  65         private static TransactionalGraphEngine dbEngine;
  66         private static Loader loader;
  67         @Mock
  68         private static DBSerializer serializer;
  69         ModelBasedProcessing processor;
  70
  71         @Mock
  72         private ModelBasedProcessing mockProcessor;
  73
  74
  75         @Mock
  76         private DbMethHelper dbMethHelper;
  77
  78         @BeforeClass
  79         public static void configure() throws Exception {
  80                 System.setProperty("AJSC_HOME", ".");
  81                 System.setProperty("BUNDLECONFIG_DIR", "src/main/resources");
  82                 loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST);
  83
  84
  85         }
  86
  87         @Before
  88         public void init() {
  89                 MockitoAnnotations.initMocks(this);
  90                 processor = new ModelBasedProcessing(loader, dbEngine, serializer);
  91
  92                 dbMethHelper = new DbMethHelper(loader, dbEngine);
  93
  94         }
  95
  96         @Test
  97         public void getStartNodesAndModVersionIdsTest() throws AAIException {
  98
  99
 100                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 101                 Map<String, Object> map = new HashMap<String, Object>();
 102                 map.put("test", new Object());
 103                 startNodeFilterArrayOfHashes.add(map);
 104                 Map<String, String> result=new HashMap<>();
 105
 106                 Map<String, String> result1 = mockProcessor.getStartNodesAndModVersionIds("test", "test",
 107                                 "test", "test", "test",
 108                                 "test", startNodeFilterArrayOfHashes,
 109                                 "test");
 110                 assertNotNull(result);
 111
 112         }
 113
 114
 115         @Test(expected = NullPointerException.class)
 116         public void getStartNodesAndModVersionIdsTest2() throws AAIException {
 117                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 118                 Map<String, Object> map = new HashMap<String, Object>();
 119                 map.put("test", new Object());
 120                 startNodeFilterArrayOfHashes.add(map);
 121                 Map<String, String> result1 = processor.getStartNodesAndModVersionIds("test", "test",
 122                                 "", "test", "test",
 123                                 "test", startNodeFilterArrayOfHashes,
 124                                 "test");
 125                 assertNotNull(result1);
 126         }
 127
 128
 129         @Test(expected = NullPointerException.class)
 130         public void getStartNodesAndModVersionIdsTest3() throws AAIException {
 131                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 132                 Map<String, Object> map = new HashMap<String, Object>();
 133                 map.put("test", new Object());
 134                 startNodeFilterArrayOfHashes.add(map);
 135                 Map<String, String> result1 = processor.getStartNodesAndModVersionIds("test", "test",
 136                                 "", "", "test",
 137                                 "test", startNodeFilterArrayOfHashes,
 138                                 "test");
 139                 assertNotNull(result1);
 140         }
 141
 142
 143         @Test(expected = AAIException.class)
 144         public void getStartNodesAndModVersionIdsTest4() throws AAIException {
 145                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 146                 Map<String, Object> map = new HashMap<String, Object>();
 147                 map.put("test", new Object());
 148                 startNodeFilterArrayOfHashes.add(map);
 149                 Map<String, String> result1 = processor.getStartNodesAndModVersionIds("test", "test",
 150                                 "", "", "",
 151                                 "test", startNodeFilterArrayOfHashes,
 152                                 "test");
 153                 assertNotNull(result1);
 154         }
 155
 156
 157         @Test(expected = AAIException.class)
 158         public void getStartNodesAndModVersionIdsTest5() throws AAIException {
 159                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 160                 Map<String, Object> map = new HashMap<String, Object>();
 161                 map.put("test", new Object());
 162                 startNodeFilterArrayOfHashes.add(map);
 163                 Map<String, String> result1 = processor.getStartNodesAndModVersionIds("test", "test",
 164                                 "", "", "",
 165                                 "", startNodeFilterArrayOfHashes,
 166                                 "test");
 167                 assertNotNull(result1);
 168         }
 169
 170
 171         @Test(expected = AAIException.class)
 172         public void getStartNodesAndModVersionIdsNullTest() throws AAIException {
 173                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 174
 175                 Map<String, String> result = null;
 176                 result = processor.getStartNodesAndModVersionIds("test", "test",
 177                                 "", "", "",
 178                                 "", startNodeFilterArrayOfHashes,
 179                                 "test");
 180
 181                 assertNotNull(result);
 182         }
 183
 184
 185         @Test(expected = NullPointerException.class)
 186         public void getStartNodesAndModVersionIdsNullTest1() throws AAIException {
 187                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 188
 189                 Map<String, String> result = null;
 190                 result = processor.getStartNodesAndModVersionIds("test", "test",
 191                                 "Test", "", "",
 192                                 "", startNodeFilterArrayOfHashes,
 193                                 "test");
 194
 195                 assertNotNull(result);
 196         }
 197
 198         @Test(expected = NullPointerException.class)
 199         public void getStartNodesAndModVersionIdsNullTest2() throws AAIException {
 200                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 201
 202                 Map<String, String> result = null;
 203                 result = processor.getStartNodesAndModVersionIds("test", "test",
 204                                 "", "test", "",
 205                                 "", startNodeFilterArrayOfHashes,
 206                                 "test");
 207                 assertNotNull(result);
 208         }
 209
 210
 211         @Test(expected = NullPointerException.class)
 212         public void getStartNodesAndModVersionIdsNullTest3() throws AAIException {
 213                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 214
 215                 Map<String, String> result = null;
 216                 result = processor.getStartNodesAndModVersionIds("test", "test",
 217                                 "", "", "test",
 218                                 "", startNodeFilterArrayOfHashes,
 219                                 "test");
 220                 assertNotNull(result);
 221         }
 222
 223         @Test(expected = NullPointerException.class)
 224         public void getModelVerTopWidgetTypeTest() throws AAIException {
 225                 Vertex vertex = new EmptyVertex();
 226                 //Mockito.when(mockProcessor.getModelVerTopWidgetType(Mockito.any(Vertex.class), Mockito.any(String.class))).thenReturn("Sucess");
 227                 String result = processor.getModelVerTopWidgetType(vertex, "test");
 228                 assertEquals("result has -local tacked on the end as it should", "Sucess", result
 229                 );
 230
 231         }
 232
 233         @Test(expected = NullPointerException.class)
 234         public void getModelVerTopWidgetType() throws AAIException {
 235                         /*Mockito.when(mockProcessor.getModelVerTopWidgetType(Mockito.any(String.class),
 236                                         Mockito.any(String.class), Mockito.any(String.class),
 237                                         Mockito.any(String.class), Mockito.any(String.class))
 238                         ).thenReturn("Sucess");*/
 239                 String result = processor.getModelVerTopWidgetType("test", "test", "test", "Test", "test");
 240                 assertEquals("result has -local tacked on the end as it should", "Sucess", result
 241                 );
 242
 243         }
 244
 245         @Test(expected = AAIException.class)
 246         public void queryByModel() throws AAIException {
 247                         /*Mockito.when(mockProcessor.getModelVerTopWidgetType(Mockito.any(String.class),
 248                                         Mockito.any(String.class), Mockito.any(String.class),
 249                                         Mockito.any(String.class), Mockito.any(String.class))
 250                         ).thenReturn("Sucess");*/
 251                 List<ResultSet> result = processor.queryByModel("test", "test",
 252                                 "test", "test", "test",
 253                                 "generic-vnf", null,
 254                                 "test");
 255                 assertEquals("result has -local tacked on the end as it should", 0, result.size());
 256
 257
 258         }
 259
 260
 261         @Test(expected = NullPointerException.class)
 262         public void queryByModel_Timed() throws AAIException {
 263                 List<Map<String, Object>> startNodeFilterArrayOfHashes = new ArrayList<Map<String, Object>>();
 264                 Map<String, Object> map = new HashMap<String, Object>();
 265                 map.put("test", new Object());
 266                 startNodeFilterArrayOfHashes.add(map);
 267                 List<ResultSet> result = processor.queryByModel_Timed("test", "test",
 268                                 "test", "test", "test",
 269                                 "test", startNodeFilterArrayOfHashes,
 270                                 "test");
 271                 assertEquals("result has -local tacked on the end as it should", 0, result.size());
 272
 273
 274         }
 275
 276         @Mock
 277         Map<String, Object> startNodeFilterHash;
 278
 279         @Test(expected = NullPointerException.class)
 280         public void runDeleteByModel() throws AAIException {
 281                 Map<String, String> resultMock = new HashMap<String, String>();
 282
 283                 //      when(mockProcessor.getNodeUsingUniqueId(any(String.class),any(String.class),any(String.class),any(String.class),any(String.class))).thenReturn(vertex);
 284                 when(mockProcessor.runDeleteByModel(any(String.class),
 285                                 any(String.class), any(String.class),
 286                                 any(String.class), anyMapOf(String.class, Object.class), any(String.class), any(String.class))
 287                 ).thenReturn(resultMock);
 288                 Map<String, String> result = processor.runDeleteByModel("test", "test",
 289                                 "test", "test", startNodeFilterHash,
 290                                 "test",
 291                                 "test");
 292                 assertEquals("result has -local tacked on the end as it should", result.size(), resultMock.size());
 293
 294
 295         }
 296
 297         Optional<Vertex> vertext = Optional.empty();
 298
 299         @Test(expected = AAIException.class)
 300         public void runDeleteByModelWithNullParams() throws AAIException {
 301                 Map<String, String> resultMock = new HashMap<String, String>();
 302
 303
 304                 Map<String, String> result = processor.runDeleteByModel("test", "test",
 305                                 null, null, null,
 306                                 "test",
 307                                 "test");
 308
 309                 assertNotNull(result);
 310
 311         }
 312
 313         @Test(expected = NullPointerException.class)
 314         public void runDeleteByModelWithNullParams1() throws AAIException {
 315
 316                 Map<String, String> result1 = processor.runDeleteByModel("test", "test",
 317                                 null, "unknown", null,
 318                                 "test",
 319                                 "test");
 320                 assertNotNull(result1);
 321
 322         }
 323
 324
 325         @Test(expected = NullPointerException.class)
 326         public void runDeleteByModelWithNullParams2() throws AAIException {
 327
 328                 Map<String, String> result1 = processor.runDeleteByModel("test", "test",
 329                                 null, "unknown", null,
 330                                 "test",
 331                                 "test");
 332                 assertNotNull(result1);
 333
 334         }
 335
 336         @Test(expected = AAIException.class)
 337         public void queryByNamedQuery() throws AAIException{
 338                 String transId="test";
 339                 String fromAppId="test";
 340                 String namedQueryUuid="test";
 341                 ArrayList <Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<Map<String,Object>>();
 342                 String apiVer="test";
 343         List<ResultSet> result=processor.queryByNamedQuery(transId,fromAppId,namedQueryUuid,startNodeFilterArrayOfHashes,apiVer);
 344         assertNotNull(result);
 345         }
 346
 347         @Test(expected = AAIException.class)
 348         public void queryByNamedQuery1() throws AAIException{
 349                 String transId="teet";
 350                 String fromAppId="test";
 351                 String namedQueryUuid="test";
 352                 String secondaryFilterCutPoint="test";
 353                 List <Map<String,Object>> startNodeFilterArrayOfHashes=new ArrayList<Map<String,Object>>();
 354                 String apiVer="test";
 355                 Map<String,Object> secondaryFilterHash=new HashMap<String,Object>();
 356                 List<ResultSet> result=processor.queryByNamedQuery(transId,fromAppId,namedQueryUuid,startNodeFilterArrayOfHashes,apiVer,secondaryFilterCutPoint,secondaryFilterHash);
 357                 assertNotNull(result);
 358         }
 359
 360         @Test
 361         public void deleteAsNeededFromResultSet() throws AAIException {
 362                 Vertex vert = new BaseVertexLabel("Test");
 363                 Map<String, String> resultMock = new HashMap<String, String>();
 364                 ResultSet resultSet = new ResultSet();
 365                 resultSet.setVert(null);
 366
 367                 Map<String, String> result = processor.deleteAsNeededFromResultSet("test", "test",
 368                                 resultSet, "test", "test",
 369                                 "test",
 370                                 resultMock);
 371
 372                 assertEquals(result.size(), 0);
 373
 374                 resultSet.setVert(vert);
 375
 376                 Map<String, String> result1 = processor.deleteAsNeededFromResultSet("test", "test",
 377                                 resultSet, "test", "test",
 378                                 "test",
 379                                 resultMock);
 380
 381                 assertEquals(result.size(), 0);
 382
 383
 384         }
 385
 386         @Test(expected = NullPointerException.class)
 387         public void pruneResultSetTest() throws AAIException {
 388                 ResultSet rs = new ResultSet();
 389                 Vertex v = new BaseVertexLabel(AAIProperties.NODE_TYPE);
 390                 rs.setVert(v);
 391                 List<ResultSet> rsList = new ArrayList<ResultSet>();
 392                 ResultSet rs1 = new ResultSet();
 393                 rsList.add(rs1);
 394                 rs.setSubResultSet(rsList);
 395                 Map<String, Object> map = new HashMap<String, Object>();
 396                 map.put("test", new Object());
 397                 ResultSet resultSet = processor.pruneResultSet(rs, "testr", map);
 398                 assertNotNull(resultSet);
 399
 400         }
 401
 402         @Test(expected = NullPointerException.class)
 403         public void satisfiesFiltersTest() throws AAIException {
 404                 ResultSet rs = new ResultSet();
 405                 Vertex v = new BaseVertexLabel(AAIProperties.NODE_TYPE);
 406                 rs.setVert(v);
 407                 rs.getVert().property(AAIProperties.NODE_TYPE);
 408                 List<ResultSet> rsList = new ArrayList<ResultSet>();
 409                 ResultSet rs1 = new ResultSet();
 410                 rsList.add(rs1);
 411                 rs.setSubResultSet(rsList);
 412                 Map<String, Object> map = new HashMap<String, Object>();
 413
 414                 map.put("modern.vertex-id", new Object());
 415
 416                 boolean result = processor.satisfiesFilters(rs, map);
 417                 assertEquals(result, true);
 418         }
 419
 420         @Test
 421         public void satisfiesFiltersTest1() throws AAIException {
 422                 ResultSet rs = new ResultSet();
 423                 Vertex v = new BaseVertexLabel(AAIProperties.NODE_TYPE);
 424                 rs.setVert(v);
 425                 List<ResultSet> rsList = new ArrayList<ResultSet>();
 426                 ResultSet rs1 = new ResultSet();
 427                 rsList.add(rs1);
 428                 rs.setSubResultSet(rsList);
 429                 Map<String, Object> map = new HashMap<String, Object>();
 430                 //map.put("test.filter",new Object());
 431
 432                 boolean result = processor.satisfiesFilters(rs, map);
 433                 assertEquals(result, false);
 434         }
 435
 436         @Test(expected = AAIException.class)
 437         public void satisfiesFiltersTest2() throws AAIException {
 438                 ResultSet rs = new ResultSet();
 439                 Vertex v = new BaseVertexLabel(AAIProperties.NODE_TYPE);
 440                 rs.setVert(v);
 441                 List<ResultSet> rsList = new ArrayList<ResultSet>();
 442                 ResultSet rs1 = new ResultSet();
 443                 rsList.add(rs1);
 444                 rs.setSubResultSet(rsList);
 445                 Map<String, Object> map = new HashMap<String, Object>();
 446                 map.put("testfilter", new Object());
 447
 448                 boolean result = processor.satisfiesFilters(rs, map);
 449                 assertEquals(result, false);
 450         }
 451
 452         @Test
 453         public void collapseForDoNotOutputTest() throws AAIException {
 454                 ResultSet rs = new ResultSet();
 455                 rs.setDoNotOutputFlag("true");
 456                 List<ResultSet> rsList = new ArrayList<ResultSet>();
 457                 ResultSet rs1 = new ResultSet();
 458                 rsList.add(rs1);
 459                 rs.setSubResultSet(rsList);
 460                 List<ResultSet> result = processor.collapseForDoNotOutput(rs);
 461                 assertEquals(result.size(), 1);
 462         }
 463
 464         @Test(expected = NullPointerException.class)
 465         public void collectInstanceDataTest() throws AAIException {
 466
 467                 BaseVertexLabel bs = new BaseVertexLabel("test");
 468                 //bs.setId(80);
 469                 EmptyVertex ev = new EmptyVertex();
 470                 //ev.setId(50l);
 471                 Vertex thisLevelElemVtx = ev;
 472
 473
 474                 Multimap<String, String> thisMap = ArrayListMultimap.create();
 475                 List<String> vidsTraversed = new ArrayList<String>();
 476                 // only applies when collecting data using the default model for delete
 477                 Multimap<String, String> validNextStepMap = ArrayListMultimap.create();
 478                 Map<String, String> namedQueryElementHash = new HashMap<String, String>();
 479                 namedQueryElementHash.put("test", "test");
 480                 Map<String, String> delKeyHash = new HashMap<String, String>();
 481
 482                 ResultSet rs = processor.collectInstanceData("test", "test", thisLevelElemVtx, "test", validNextStepMap, vidsTraversed, 1, delKeyHash, namedQueryElementHash, "test");
 483         }
 484
 485         @Test(expected = NullPointerException.class)
 486         public void genTopoMap4ModelVerTest() throws
 487                         AAIException {
 488                 Vertex vertext = new EmptyVertex();
 489                 Multimap<String, String> map = processor.genTopoMap4ModelVer("test", "test", vertext, "test");
 490                 assertNotEquals(map, null);
 491         }
 492
 493         @Test(expected = AAIException.class)
 494         public void genTopoMap4ModelVerTestNull() throws
 495                         AAIException {
 496                 Vertex vertext = null;
 497                 Multimap<String, String> map = processor.genTopoMap4ModelVer("test", "test", vertext, "test");
 498                 assertNotEquals(map, null);
 499         }
 500
 501         @Test
 502         public void makeSureItsAnArrayListTest() {
 503                 String input = "model-versionId,modelTestID,modelTestid2;";
 504                 List<String> result = processor.makeSureItsAnArrayList(input);
 505                 assertTrue(result.size() > 0);
 506         }
 507
 508         @Test(expected = AAIException.class)
 509         public void getModConstraintHashTest() throws AAIException {
 510                 Vertex modelElementVtx = new EmptyVertex();
 511                 //modelElementVtx.property(AAIProperties.NODE_TYPE,"Model");
 512                 Vertex modelElementVtx1 = new EmptyVertex();
 513                 Map<String, Vertex> currentHash = new HashMap<String, Vertex>();
 514                 currentHash.put("constraint", modelElementVtx1);
 515                 Map<String, Vertex> result = processor.getModConstraintHash(modelElementVtx, currentHash);
 516                 assertTrue(result.size() > 0);
 517         }
 518
 519         @Test(expected = AAIException.class)
 520         public void getModConstraintHashTestNull() throws AAIException {
 521                 Vertex modelElementVtx = null;
 522                 //modelElementVtx.property(AAIProperties.NODE_TYPE,"Model");
 523                 Vertex modelElementVtx1 =null;
 524                 Map<String, Vertex> currentHash = new HashMap<String, Vertex>();
 525                 currentHash.put("constraint", modelElementVtx1);
 526                 Map<String, Vertex> result = processor.getModConstraintHash(modelElementVtx, currentHash);
 527                 assertTrue(result.size() > 0);
 528         }
 529
 530         @Test(expected = NullPointerException.class)
 531         public void getTopElementForSvcOrResModelVerTest() throws AAIException {
 532                 Vertex modelElementVtx = new EmptyVertex();
 533                 //modelElementVtx.property(AAIProperties.NODE_TYPE,"Model");
 534                 Vertex modelElementVtx1 = new EmptyVertex();
 535                 Map<String, Vertex> currentHash = new HashMap<String, Vertex>();
 536                 currentHash.put("constraint", modelElementVtx1);
 537                 Vertex result = processor.getTopElementForSvcOrResModelVer(modelElementVtx, "test");
 538                 assertNotEquals(result, null);
 539         }
 540
 541         @Test
 542         public void getNamedQueryPropOverRideTest() throws AAIException {
 543                 String transId = "test";
 544                 String fromAppId = "test";
 545                 Vertex namedQueryElementVertex = new EmptyVertex();
 546                 Vertex instanceVertex = new EmptyVertex();
 547                 String apiVer = "test";
 548
 549                 namedQueryElementVertex.properties("property-collect-list", "");
 550
 551                 Map<String, Object> result = processor.getNamedQueryPropOverRide(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 552                 assertNotEquals(result, null);
 553         }
 554
 555         @Test(expected = NullPointerException.class)
 556         public void getNamedQueryPropOverRideTestNull() throws AAIException {
 557                 String transId = "test";
 558                 String fromAppId = "test";
 559                 Vertex namedQueryElementVertex = null;
 560                 Vertex instanceVertex = new EmptyVertex();
 561                 String apiVer = "test";
 562
 563                 namedQueryElementVertex.properties("property-collect-list", "");
 564
 565                 Map<String, Object> result = processor.getNamedQueryPropOverRide(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 566                 assertNotEquals(result, null);
 567         }
 568
 569         @Test(expected = NullPointerException.class)
 570         public void namedQueryConstraintSaysStopTest() throws AAIException {
 571                 String transId = "test";
 572                 String fromAppId = "test";
 573                 Vertex namedQueryElementVertex = new EmptyVertex();
 574                 Vertex instanceVertex = new EmptyVertex();
 575                 String apiVer = "test";
 576
 577                 namedQueryElementVertex.properties("property-collect-list", "");
 578
 579                 boolean result = processor.namedQueryConstraintSaysStop(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 580                 assertTrue(result);
 581         }
 582
 583         @Test(expected = NullPointerException.class)
 584         public void namedQueryConstraintSaysStopTestNull() throws AAIException {
 585                 String transId = "test";
 586                 String fromAppId = "test";
 587                 Vertex namedQueryElementVertex = null;
 588                 Vertex instanceVertex = new EmptyVertex();
 589                 String apiVer = "test";
 590
 591                 namedQueryElementVertex.properties("property-collect-list", "");
 592
 593                 boolean result = processor.namedQueryConstraintSaysStop(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 594                 assertTrue(result);
 595         }
 596
 597         @Test(expected = AAIException.class)
 598         public void namedQuerynamedQueryElementVertexNullTest() throws AAIException {
 599                 String transId = "test";
 600                 String fromAppId = "test";
 601                 Vertex namedQueryElementVertex = null;
 602                 Vertex instanceVertex = null;
 603                 String apiVer = "test";
 604
 605
 606                 boolean result = processor.namedQueryConstraintSaysStop(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 607                 assertTrue(result);
 608         }
 609
 610         @Test(expected = NullPointerException.class)
 611
 612         public void getNamedQueryExtraDataLookupTest() throws Exception {
 613
 614                 String transId = "test";
 615                 String fromAppId = "test";
 616                 Vertex namedQueryElementVertex = new EmptyVertex();
 617                 Vertex instanceVertex = new EmptyVertex();
 618                 String apiVer = "test";
 619
 620                 namedQueryElementVertex.properties("property-collect-list", "");
 621
 622                 Map<String, Object> result = processor.getNamedQueryExtraDataLookup(transId, fromAppId, namedQueryElementVertex, instanceVertex, apiVer);
 623
 624                 assertTrue(result.size() > 0);
 625         }
 626
 627         @Test(expected = NullPointerException.class)
 628         public void collectNQElementHash() throws AAIException {
 629                 String transId = "test";
 630                 String fromAppId = "test";
 631                 Vertex thisLevelElemVtx = new EmptyVertex();
 632                 String incomingTrail = "test";
 633                 Map<String, String> currentHash = new HashMap<String, String>();
 634                 ArrayList<String> vidsTraversed = new ArrayList<String>();
 635                 int levelCounter = 1;
 636
 637                 Map<String, String> result = processor.collectNQElementHash(transId, fromAppId,
 638                                 thisLevelElemVtx, incomingTrail, currentHash,
 639                                 vidsTraversed, levelCounter);
 640
 641                 assertNotEquals(result, null);
 642         }
 643
 644         @Test(expected = NullPointerException.class)
 645         public void collectDeleteKeyHash() throws AAIException {
 646                 String transId = "test";
 647                 String fromAppId = "test";
 648                 Vertex thisLevelElemVtx = new EmptyVertex();
 649                 String incomingTrail = "test";
 650                 Map<String, String> currentHash = new HashMap<String, String>();
 651                 ArrayList<String> vidsTraversed = new ArrayList<String>();
 652                 int levelCounter = 1;
 653                 Map<String, Vertex> modConstraintHash = new HashMap<String, Vertex>();
 654                 String overRideModelId = "test";
 655                 String overRideModelVersionId = "test";
 656
 657                 Map<String, String> result = processor.collectDeleteKeyHash(transId, fromAppId,
 658                                 thisLevelElemVtx, incomingTrail, currentHash,
 659                                 vidsTraversed, levelCounter, modConstraintHash, overRideModelId, overRideModelVersionId);
 660
 661                 assertNotEquals(result, null);
 662         }
 663
 664         @Test
 665         public void getLinkageConnectNodeTypesTest() throws AAIException {
 666                 List<String> linkagePtList = new ArrayList<String>();
 667                 linkagePtList.add("modern\\|testdata\\|");
 668                 Set<String> result = processor.getLinkageConnectNodeTypes(linkagePtList);
 669                 assertNotEquals(result, null);
 670
 671         }
 672
 673         @Test(expected = AAIException.class)
 674         public void getLinkageConnectNodeTypesTest1() throws AAIException {
 675
 676                 Set<String> result1 = processor.getLinkageConnectNodeTypes(null);
 677                 assertNotEquals(result1, null);
 678
 679                 List<String> linkagePtList = new ArrayList<String>();
 680                 linkagePtList.add("moderntestdata");
 681                 Set<String> result = processor.getLinkageConnectNodeTypes(linkagePtList);
 682                 assertNotEquals(result, null);
 683         }
 684
 685         @Test(expected = NullPointerException.class)
 686         public void collectTopology4ModelVerTest() throws AAIException {
 687                 String transId = "test";
 688                 String fromAppId = "test";
 689                 Multimap<String, String> thisMap = ArrayListMultimap.create();
 690                 Vertex thisLevelElemVtx = new EmptyVertex();
 691                 String incomingTrail = "test";
 692                 Map<String, Vertex> currentHash = new HashMap<String, Vertex>();
 693                 List<String> vidsTraversed = new ArrayList<String>();
 694                 int levelCounter = 1;
 695
 696                 Multimap<String, String> result = processor.collectTopology4ModelVer(transId, fromAppId,
 697                                 thisLevelElemVtx, incomingTrail, thisMap, vidsTraversed, levelCounter, currentHash
 698                                 , "test", "test");
 699
 700                 assertNotEquals(result, null);
 701         }
 702
 703         @Test(expected = AAIException.class)
 704         public void check4EdgeRuleTest() throws AAIException {
 705                 processor.check4EdgeRule("test", "test");
 706         }
 707
 708         @Test(expected = AAIException.class)
 709         public void collectTopology4LinkagePointTest() throws AAIException {
 710                 String transId = "test";
 711                 String fromAppId = "test";
 712                 String linkagePointStrVal = "test";
 713                 String incomingTrail = "test";
 714                 Multimap<String, String> currentMap = ArrayListMultimap.create();
 715
 716                 Multimap<String, String> result = processor.collectTopology4LinkagePoint(transId, fromAppId, linkagePointStrVal, incomingTrail, currentMap);
 717                 assertNotEquals(result, null);
 718
 719         }
 720
 721         @Test(expected = AAIException.class)
 722         public void getNextStepElementsFromSet() throws AAIException {
 723                 Vertex constrElemSetVtx = new EmptyVertex();
 724                 constrElemSetVtx.<String>property(AAIProperties.NODE_TYPE);
 725                 Map<String, Object> result = processor.getNextStepElementsFromSet(constrElemSetVtx);
 726                 assertNotEquals(result, null);
 727         }
 728
 729         @Test(expected = NullPointerException.class)
 730         public void genTopoMap4NamedQTest() throws AAIException {
 731                 String transId = "test";
 732                 String fromAppId = "test";
 733                 Vertex queryVertex = new EmptyVertex();
 734                 String namedQueryUuid = "E44533334343";
 735                 Multimap<String, String> result = processor.genTopoMap4NamedQ(transId, fromAppId, queryVertex, namedQueryUuid);
 736                 assertNotEquals(result, null);
 737         }
 738
 739         @Test(expected = NullPointerException.class)
 740         public void collectTopology4NamedQTest() throws AAIException {
 741                 String transId = "test";
 742                 String fromAppId = "test";
 743                 Multimap<String, String> thisMap = ArrayListMultimap.create();
 744                 Vertex thisLevelElemVtx = new EmptyVertex();
 745                 String incomingTrail = "test";
 746                 Map<String, Vertex> currentHash = new HashMap<String, Vertex>();
 747                 List<String> vidsTraversed = new ArrayList<String>();
 748                 int levelCounter = 1;
 749
 750                 Multimap<String, String> result = processor.collectTopology4NamedQ(transId, fromAppId,
 751                                 thisLevelElemVtx, incomingTrail, thisMap, vidsTraversed, levelCounter);
 752                 assertNotEquals(result, null);
 753         }
 754
 755         @Test(expected = NullPointerException.class)
 756         public void getModelThatNqElementRepresentsTest() throws AAIException {
 757                 Vertex thisLevelElemVtx = new EmptyVertex();
 758                 String incomingTrail = "test";
 759                 Vertex vertex = processor.getModelThatNqElementRepresents(thisLevelElemVtx, incomingTrail);
 760                 assertNotEquals(vertex, null);
 761         }
 762
 763         @Test(expected = NullPointerException.class)
 764         public void getModelGivenModelVer() throws AAIException {
 765                 Vertex thisLevelElemVtx = new EmptyVertex();
 766                 String incomingTrail = "test";
 767                 Vertex vertex = processor.getModelGivenModelVer(thisLevelElemVtx, incomingTrail);
 768                 assertNotEquals(vertex, null);
 769         }
 770
 771         @Test(expected = AAIException.class)
 772         public void getModelTypeFromModel() throws AAIException {
 773                 Vertex thisLevelElemVtx = new EmptyVertex();
 774                 String incomingTrail = "test";
 775                 String vertex = processor.getModelTypeFromModel(thisLevelElemVtx, incomingTrail);
 776                 assertNotEquals(vertex, null);
 777         }
 778
 779         @Test(expected = NullPointerException.class)
 780         public void getModelTypeFromModelVer() throws AAIException {
 781                 Vertex thisLevelElemVtx = new EmptyVertex();
 782                 String incomingTrail = "test";
 783                 String vertex = processor.getModelTypeFromModelVer(thisLevelElemVtx, incomingTrail);
 784                 assertNotEquals(vertex, null);
 785         }
 786
 787         @Test(expected = NullPointerException.class)
 788         public void getModelElementStepName() throws AAIException {
 789                 Vertex thisLevelElemVtx = new EmptyVertex();
 790                 String incomingTrail = "test";
 791                 String vertex = processor.getModelElementStepName(thisLevelElemVtx, incomingTrail);
 792                 assertNotEquals(vertex, null);
 793         }
 794
 795         @Test(expected = AAIException.class)
 796         public void nodeTypeSupportsPersona() throws AAIException {
 797                 String incomingTrail = "";
 798                 boolean vertex = processor.nodeTypeSupportsPersona(incomingTrail);
 799                 assertFalse(vertex);
 800
 801
 802                 incomingTrail = "test";
 803                 boolean vertex1 = processor.nodeTypeSupportsPersona(incomingTrail);
 804                 assertTrue(vertex1);
 805         }
 806
 807         @Test(expected = NullPointerException.class)
 808         public void getNqElementWidgetType() throws  AAIException{
 809                 String appId="test";
 810                 String transID="test";
 811                 Vertex thisLevelElemVtx = new EmptyVertex();
 812                 String incomingTrail = "test";
 813                 String vertex1 = processor.getNqElementWidgetType(appId,transID,thisLevelElemVtx,incomingTrail);
 814                 assertNotEquals(vertex1,null);
 815         }
 816
 817
 818         @Test(expected = NullPointerException.class)
 819         public void getModElementWidgetType() throws  AAIException{
 820                 String appId="test";
 821                 String transID="test";
 822                 Vertex thisLevelElemVtx = new EmptyVertex();
 823                 String incomingTrail = "test";
 824                 String vertex1 = processor.getModElementWidgetType(thisLevelElemVtx,incomingTrail);
 825                 assertNotEquals(vertex1,null);
 826         }
 827
 828         @Test(expected = NullPointerException.class)
 829         public void getNodeUsingUniqueId() throws  AAIException{
 830                 String appId="test";
 831                 String transID="test";
 832                 String nodeType = "generic-vnf";
 833                 String idPropertyName = "test";
 834                 String uniqueIdVal="test";
 835                 Vertex vertex1 = processor.getNodeUsingUniqueId(transID,appId,nodeType,idPropertyName,uniqueIdVal);
 836                 assertNotEquals(vertex1,null);
 837         }
 838
 839
 840         @Test(expected = AAIException.class)
 841         public void getNodeUsingUniqueIdNull() throws  AAIException{
 842                 String appId="test";
 843                 String transID="test";
 844                 String nodeType = "generic-vnf";
 845                 String idPropertyName = "test";
 846                 String uniqueIdVal="";
 847                 Vertex vertex1 = null;
 848                 vertex1=        processor.getNodeUsingUniqueId(transID,appId,nodeType,idPropertyName,uniqueIdVal);
 849                 assertNotEquals(vertex1,null);
 850
 851         }
 852
 853
 854         @Test(expected = AAIException.class)
 855         public void getNodeUsingUniqueIdNull1() throws  AAIException{
 856                 String appId="test";
 857                 String transID="test";
 858                 String nodeType = "generic-vnf";
 859                 String idPropertyName="";
 860                 String uniqueIdVal="test";
 861                 Vertex vertex1 = null;
 862                 vertex1=        processor.getNodeUsingUniqueId(transID,appId,nodeType,idPropertyName,uniqueIdVal);
 863                 assertNotEquals(vertex1,null);
 864
 865
 866         }
 867
 868
 869         @Test(expected = AAIException.class)
 870         public void getNodeUsingUniqueIdNull2() throws  AAIException{
 871                 String appId="test";
 872                 String transID="test";
 873                 String nodeType = "";
 874                 String idPropertyName="test";
 875                 String uniqueIdVal="test";
 876                 Vertex vertex1 = null;
 877                 vertex1=        processor.getNodeUsingUniqueId(transID,appId,nodeType,idPropertyName,uniqueIdVal);
 878                 assertNotEquals(vertex1,null);
 879
 880
 881         }
 882
 883         @Test(expected = NullPointerException.class)
 884         public void getModelVersUsingName() throws AAIException{
 885                 String appId="test";
 886                 String transID="test";
 887                 String modelName = "test";
 888
 889                 List<Vertex> result=    processor.getModelVersUsingName(transID,appId,modelName);
 890                 assertNotEquals(result,null);
 891         }
 892
 893
 894         @Test(expected = AAIException.class)
 895         public void getModelVersUsingNameNull() throws AAIException{
 896                 String appId="test";
 897                 String transID="test";
 898                 String modelName = "";
 899
 900                 List<Vertex> result=    processor.getModelVersUsingName(transID,appId,modelName);
 901                 assertNotEquals(result,null);
 902         }
 903
 904
 905         @Test(expected = NullPointerException.class)
 906         public void getModVersUsingModelInvId() throws AAIException{
 907                 String appId="test";
 908                 String transID="test";
 909                 String modelName = "test";
 910
 911                 Iterator<Vertex> result=        processor.getModVersUsingModelInvId(transID,appId,modelName);
 912                 assertNotEquals(result,null);
 913         }
 914
 915         @Test(expected = AAIException.class)
 916         public void getModVersUsingModelInvIdNull() throws AAIException{
 917                 String appId="test";
 918                 String transID="test";
 919                 String modelName = "";
 920
 921                 Iterator<Vertex> result=        processor.getModVersUsingModelInvId(transID,appId,modelName);
 922                 assertNotEquals(result,null);
 923         }
 924
 925         @Test(expected = NullPointerException.class)
 926         public void getModVersUsingModel() throws AAIException{
 927                 String appId="test";
 928                 String transID="test";
 929                 String modelName = "test";
 930                 Vertex thisLevelElemVtx = new EmptyVertex();
 931                 List<Vertex> result=    processor.getModVersUsingModel(transID,appId,thisLevelElemVtx);
 932                 assertNotEquals(result,null);
 933         }
 934
 935         @Test(expected = AAIException.class)
 936         public void getModVersUsingModel1() throws AAIException{
 937                 String appId="test";
 938                 String transID="test";
 939
 940                 Vertex thisLevelElemVtx = null;
 941                 List<Vertex> result=    processor.getModVersUsingModel(transID,appId,thisLevelElemVtx);
 942                 assertNotEquals(result,null);
 943         }
 944
 945         @Test(expected = NullPointerException.class)
 946         public void getModelVerIdsUsingName() throws AAIException{
 947                 String appId="test";
 948                 String transID="test";
 949
 950                 String modelName= "test";
 951                 List<String> result=    processor.getModelVerIdsUsingName(transID,appId,modelName);
 952                 assertNotEquals(result,null);
 953         }
 954
 955         @Test(expected = AAIException.class)
 956         public void getModelVerIdsUsingName1() throws AAIException{
 957                 String appId="test";
 958                 String transID="test";
 959
 960                 String modelName= "";
 961                 List<String> result=    processor.getModelVerIdsUsingName(transID,appId,modelName);
 962                 assertNotEquals(result,null);
 963         }
 964
 965         @Test(expected =NullPointerException.class)
 966         public void validateModel() throws  AAIException{
 967                 String appId="test";
 968                 String transID="test";
 969
 970                 String modelVersionId= "test";
 971                 String modelInvId= "test";
 972                 String modelName= "test";
 973                 processor.validateModel(transID,appId,modelName,modelVersionId);
 974
 975
 976         }
 977
 978
 979
 980 }
 981