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