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

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