aai-core/src/test/java/org/openecomp/aai/parsers/query/GraphTraversalTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   4  * ================================================================================
   5  * Copyright (C) 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
  21 package org.openecomp.aai.parsers.query;
  22
  23 import static org.hamcrest.CoreMatchers.containsString;
  24 import static org.hamcrest.Matchers.hasProperty;
  25 import static org.hamcrest.Matchers.is;
  26 import static org.junit.Assert.assertEquals;
  27
  28 import java.io.UnsupportedEncodingException;
  29 import java.net.URI;
  30 import java.util.ArrayList;
  31 import java.util.List;
  32
  33 import javax.ws.rs.core.MultivaluedHashMap;
  34 import javax.ws.rs.core.MultivaluedMap;
  35 import javax.ws.rs.core.UriBuilder;
  36
  37 import org.apache.tinkerpop.gremlin.process.traversal.P;
  38 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  39 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  40 import org.apache.tinkerpop.gremlin.structure.Vertex;
  41 import org.junit.BeforeClass;
  42 import org.junit.Rule;
  43 import org.junit.Test;
  44 import org.junit.rules.ExpectedException;
  45
  46 import org.openecomp.aai.db.props.AAIProperties;
  47 import org.openecomp.aai.exceptions.AAIException;
  48 import org.openecomp.aai.introspection.LoaderFactory;
  49 import org.openecomp.aai.introspection.ModelType;
  50 import org.openecomp.aai.introspection.Version;
  51 import org.openecomp.aai.serialization.engines.QueryStyle;
  52 import org.openecomp.aai.serialization.engines.TitanDBEngine;
  53 import org.openecomp.aai.serialization.engines.TransactionalGraphEngine;
  54 import org.openecomp.aai.serialization.queryformats.QueryFormatTestHelper;
  55 import org.openecomp.aai.util.AAIConstants;
  56
  57
  58 public class GraphTraversalTest {
  59
  60         private static TransactionalGraphEngine dbEngine;
  61
  62         private static TransactionalGraphEngine dbEnginev9;
  63
  64         @Rule
  65         public ExpectedException thrown = ExpectedException.none();
  66
  67         /**
  68          * Configure.
  69          * @throws Exception
  70          * @throws SecurityException
  71          * @throws NoSuchFieldException
  72          */
  73         @BeforeClass
  74         public static void configure() throws NoSuchFieldException, SecurityException, Exception {
  75                 System.setProperty("AJSC_HOME", "./src/test/resources/");
  76                 System.setProperty("BUNDLECONFIG_DIR", "bundleconfig-local");
  77                 QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/org/openecomp/aai/introspection/");
  78                 dbEngine =
  79                                 new TitanDBEngine(QueryStyle.TRAVERSAL,
  80                                         LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST),
  81                                         false);
  82
  83                 dbEnginev9 =
  84                                 new TitanDBEngine(QueryStyle.TRAVERSAL,
  85                                         LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v9),
  86                                         false);
  87         }
  88
  89         /**
  90          * Parent query.
  91          *
  92          * @throws UnsupportedEncodingException the unsupported encoding exception
  93          * @throws AAIException the AAI exception
  94          */
  95         @Test
  96     public void parentQuery() throws UnsupportedEncodingException, AAIException {
  97                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1").build();
  98
  99                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 100
 101                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start().has("physical-location-id", "key1").has("aai-node-type", "complex");
 102                 assertEquals(
 103                                 "gremlin query should be " + expected.toString(),
 104                                 expected.toString(),
 105                                 query.getQueryBuilder().getQuery().toString());
 106                 assertEquals(
 107                                 "parent gremlin query should be equal to normal query",
 108                                 expected.toString(),
 109                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 110                 assertEquals(
 111                                 "result type should be complex",
 112                                 "complex",
 113                                 query.getResultType());
 114                 assertEquals(
 115                                 "result type should be empty",
 116                                 "",
 117                                 query.getParentResultType());
 118                 assertEquals("dependent",false, query.isDependent());
 119
 120
 121     }
 122
 123         /**
 124          * Child query.
 125          *
 126          * @throws UnsupportedEncodingException the unsupported encoding exception
 127          * @throws AAIException the AAI exception
 128          */
 129         @Test
 130     public void childQuery() throws UnsupportedEncodingException, AAIException {
 131                 URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/ctag-pools/ctag-pool/key2/key3").build();
 132                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 133                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 134                                 .has("physical-location-id", "key1").has("aai-node-type", "complex")
 135                                 .out("hasCtagPool")
 136                                 .has("aai-node-type", "ctag-pool")
 137                                 .has("target-pe", "key2").has("availability-zone-name", "key3");
 138                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 139                                 .has("physical-location-id", "key1").has("aai-node-type", "complex");
 140                 assertEquals(
 141                                 "gremlin query should be " + expected.toString(),
 142                                 expected.toString(),
 143                                 query.getQueryBuilder().getQuery().toString());
 144                 assertEquals(
 145                                 "parent gremlin query should be equal the query for complex",
 146                                 expectedParent.toString(),
 147                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 148                 assertEquals(
 149                                 "result type should be complex",
 150                                 "complex",
 151                                 query.getParentResultType());
 152                 assertEquals(
 153                                 "result type should be ctag-pool",
 154                                 "ctag-pool",
 155                                 query.getResultType());
 156                 assertEquals("dependent",true, query.isDependent());
 157
 158
 159     }
 160
 161         /**
 162          * Naming exceptions.
 163          *
 164          * @throws UnsupportedEncodingException the unsupported encoding exception
 165          * @throws AAIException the AAI exception
 166          */
 167         @Test
 168     public void namingExceptions() throws UnsupportedEncodingException, AAIException {
 169                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags/cvlan-tag/655").build();
 170                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 171                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 172                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 173                                 .out("hasPortGroup")
 174                                 .has("aai-node-type", "port-group")
 175                                 .has("interface-id", "key2").out("hasCTag")
 176                                 .has("aai-node-type", "cvlan-tag")
 177                                 .has("cvlan-tag", 655);
 178                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 179                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 180                                 .out("hasPortGroup")
 181                                 .has("aai-node-type", "port-group")
 182                                 .has("interface-id", "key2");
 183                 assertEquals(
 184                                 "gremlin query should be " + expected.toString(),
 185                                 expected.toString(),
 186                                 query.getQueryBuilder().getQuery().toString());
 187                 assertEquals(
 188                                 "parent gremlin query should be equal the query for port group",
 189                                 expectedParent.toString(),
 190                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 191                 assertEquals(
 192                                 "result type should be cvlan-tag",
 193                                 "cvlan-tag",
 194                                 query.getResultType());
 195                 assertEquals(
 196                                 "result type should be port-group",
 197                                 "port-group",
 198                                 query.getParentResultType());
 199                 assertEquals(
 200                                 "contaner type should be empty",
 201                                 "",
 202                                 query.getContainerType());
 203                 assertEquals("dependent",true, query.isDependent());
 204
 205
 206     }
 207
 208         /**
 209          * Gets the all.
 210          *
 211          * @return the all
 212          * @throws UnsupportedEncodingException the unsupported encoding exception
 213          * @throws AAIException the AAI exception
 214          */
 215         @Test
 216     public void getAll() throws UnsupportedEncodingException, AAIException {
 217                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 218                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 219                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 220                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 221                                 .out("hasPortGroup")
 222                                 .has("aai-node-type", "port-group")
 223                                 .has("interface-id", "key2").out("hasCTag")
 224                                 .has("aai-node-type", "cvlan-tag");
 225                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 226                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 227                                 .out("hasPortGroup")
 228                                 .has("aai-node-type", "port-group")
 229                                 .has("interface-id", "key2");
 230                 assertEquals(
 231                                 "gremlin query should be " + expected.toString(),
 232                                 expected.toString(),
 233                                 query.getQueryBuilder().getQuery().toString());
 234                 assertEquals(
 235                                 "parent gremlin query should be equal the query for port group",
 236                                 expectedParent.toString(),
 237                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 238                 assertEquals(
 239                                 "result type should be port-group",
 240                                 "port-group",
 241                                 query.getParentResultType());
 242                 assertEquals(
 243                                 "result type should be cvlan-tag",
 244                                 "cvlan-tag",
 245                                 query.getResultType());
 246                 assertEquals(
 247                                 "container type should be cvlan-tags",
 248                                 "cvlan-tags",
 249                                 query.getContainerType());
 250                 assertEquals("dependent",true, query.isDependent());
 251
 252
 253     }
 254
 255         @Test
 256     public void getAllParent() throws UnsupportedEncodingException, AAIException {
 257                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers").build();
 258                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 259                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 260                                 .has("aai-node-type", "pserver");
 261                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 262                                 .has("aai-node-type", "pserver");
 263                 assertEquals(
 264                                 "gremlin query should be " + expected.toString(),
 265                                 expected.toString(),
 266                                 query.getQueryBuilder().getQuery().toString());
 267                 assertEquals(
 268                                 "parent gremlin query should be equal the query for pserver",
 269                                 expectedParent.toString(),
 270                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 271                 assertEquals(
 272                                 "parent result type should be empty",
 273                                 "",
 274                                 query.getParentResultType());
 275                 assertEquals(
 276                                 "result type should be pserver",
 277                                 "pserver",
 278                                 query.getResultType());
 279                 assertEquals(
 280                                 "container type should be pservers",
 281                                 "pservers",
 282                                 query.getContainerType());
 283                 assertEquals("dependent",false, query.isDependent());
 284
 285
 286     }
 287
 288
 289         /**
 290          * Gets the via query param.
 291          *
 292          * @return the via query param
 293          * @throws UnsupportedEncodingException the unsupported encoding exception
 294          * @throws AAIException the AAI exception
 295          */
 296         @Test
 297         public void getViaQueryParam() throws UnsupportedEncodingException, AAIException {
 298                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 299                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 300                 map.putSingle("tenant-name", "Tenant1");
 301                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 302                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 303                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 304                                 .has("aai-node-type", "cloud-region")
 305                                 .out("has")
 306                                 .has("aai-node-type", "tenant")
 307                                 .has("tenant-name", "Tenant1");
 308
 309                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 310                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 311                                 .has("aai-node-type", "cloud-region");
 312
 313                 assertEquals(
 314                                 "gremlin query should be " + expected.toString(),
 315                                 expected.toString(),
 316                                 query.getQueryBuilder().getQuery().toString());
 317                 assertEquals(
 318                                 "parent gremlin query should be equal the query for cloud-region",
 319                                 expectedParent.toString(),
 320                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 321                 assertEquals(
 322                                 "result type should be cloud-region",
 323                                 "cloud-region",
 324                                 query.getParentResultType());
 325                 assertEquals(
 326                                 "result type should be tenant",
 327                                 "tenant",
 328                                 query.getResultType());
 329                 assertEquals(
 330                                 "container type should be empty",
 331                                 "",
 332                                 query.getContainerType());
 333                 assertEquals("dependent",true, query.isDependent());
 334
 335         }
 336
 337         @Test
 338         public void getViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 339                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 340                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 341                 List<String> values = new ArrayList<>();
 342                 values.add("Tenant1");
 343                 values.add("Tenant2");
 344                 map.put("tenant-name", values);
 345                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 346                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 347                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 348                                 .has("aai-node-type", "cloud-region")
 349                                 .out("has")
 350                                 .has("aai-node-type", "tenant")
 351                                 .has("tenant-name", P.within(values));
 352
 353                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 354                                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 355                                 .has("aai-node-type", "cloud-region");
 356
 357                 assertEquals(
 358                                 "gremlin query should be " + expected.toString(),
 359                                 expected.toString(),
 360                                 query.getQueryBuilder().getQuery().toString());
 361                 assertEquals(
 362                                 "parent gremlin query should be equal the query for cloud-region",
 363                                 expectedParent.toString(),
 364                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 365                 assertEquals(
 366                                 "result type should be cloud-region",
 367                                 "cloud-region",
 368                                 query.getParentResultType());
 369                 assertEquals(
 370                                 "result type should be tenant",
 371                                 "tenant",
 372                                 query.getResultType());
 373                 assertEquals(
 374                                 "container type should be empty",
 375                                 "",
 376                                 query.getContainerType());
 377                 assertEquals("dependent",true, query.isDependent());
 378
 379         }
 380
 381         /**
 382          * Gets the plural via query param.
 383          *
 384          * @return the plural via query param
 385          * @throws UnsupportedEncodingException the unsupported encoding exception
 386          * @throws AAIException the AAI exception
 387          */
 388         @Test
 389         public void getPluralViaQueryParam() throws UnsupportedEncodingException, AAIException {
 390                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 391                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 392                 map.putSingle("prov-status", "up");
 393                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 394                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 395                                 .has("aai-node-type", "vnfc")
 396                                 .has("prov-status", "up");
 397
 398                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 399                                 .has("aai-node-type", "vnfc");
 400
 401                 assertEquals(
 402                                 "gremlin query should be " + expected.toString(),
 403                                 expected.toString(),
 404                                 query.getQueryBuilder().getQuery().toString());
 405                 assertEquals(
 406                                 "parent",
 407                                 expectedParent.toString(),
 408                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 409                 assertEquals(
 410                                 "parent result type should be empty",
 411                                 "",
 412                                 query.getParentResultType());
 413                 assertEquals(
 414                                 "result type should be vnfc",
 415                                 "vnfc",
 416                                 query.getResultType());
 417                 assertEquals(
 418                                 "container type should be empty",
 419                                 "vnfcs",
 420                                 query.getContainerType());
 421                 assertEquals("dependent",true, query.isDependent());
 422
 423         }
 424
 425         /**
 426          * Gets the all query param naming exception.
 427          *
 428          * @return the all query param naming exception
 429          * @throws UnsupportedEncodingException the unsupported encoding exception
 430          * @throws AAIException the AAI exception
 431          */
 432         @Test
 433     public void getAllQueryParamNamingException() throws UnsupportedEncodingException, AAIException {
 434                 URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 435                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 436                 map.putSingle("cvlan-tag", "333");
 437                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 438
 439                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 440                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 441                                 .out("hasPortGroup")
 442                                 .has("aai-node-type", "port-group")
 443                                 .has("interface-id", "key2").out("hasCTag")
 444                                 .has("aai-node-type", "cvlan-tag")
 445                                 .has("cvlan-tag", 333);
 446                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 447                                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 448                                 .out("hasPortGroup")
 449                                 .has("aai-node-type", "port-group")
 450                                 .has("interface-id", "key2");
 451                 assertEquals(
 452                                 "gremlin query should be " + expected.toString(),
 453                                 expected.toString(),
 454                                 query.getQueryBuilder().getQuery().toString());
 455                 assertEquals(
 456                                 "parent gremlin query should be equal the query for port group",
 457                                 expectedParent.toString(),
 458                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 459                 assertEquals(
 460                                 "result type should be port-group",
 461                                 "port-group",
 462                                 query.getParentResultType());
 463                 assertEquals(
 464                                 "result type should be cvlan-tag",
 465                                 "cvlan-tag",
 466                                 query.getResultType());
 467                 assertEquals(
 468                                 "container type should be cvlan-tags",
 469                                 "cvlan-tags",
 470                                 query.getContainerType());
 471                 assertEquals("dependent",true, query.isDependent());
 472
 473
 474     }
 475
 476         /**
 477          * Abstract type.
 478          *
 479          * @throws UnsupportedEncodingException the unsupported encoding exception
 480          * @throws AAIException the AAI exception
 481          */
 482         @Test
 483     public void abstractType() throws UnsupportedEncodingException, AAIException {
 484                 URI uri = UriBuilder.fromPath("vnf/key1").build();
 485
 486                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 487
 488                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 489                                 .has("vnf-id", "key1").or(
 490                                                 __.has(AAIProperties.NODE_TYPE, "vce"),
 491                                                 __.has(AAIProperties.NODE_TYPE, "vpe"),
 492                                                 __.has(AAIProperties.NODE_TYPE, "generic-vnf"));
 493
 494                 GraphTraversal<Vertex, Vertex> expectedParent = expected;
 495                 assertEquals(
 496                                 "gremlin query should be " + expected.toString(),
 497                                 expected.toString(),
 498                                 query.getQueryBuilder().getQuery().toString());
 499                 assertEquals(
 500                                 "parent gremlin query should be equal the query for port group",
 501                                 expectedParent.toString(),
 502                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 503                 assertEquals(
 504                                 "result type should be empty",
 505                                 "",
 506                                 query.getParentResultType());
 507                 assertEquals(
 508                                 "result type should be vnf",
 509                                 "vnf",
 510                                 query.getResultType());
 511
 512                 assertEquals("dependent",false, query.isDependent());
 513
 514
 515     }
 516
 517         /**
 518          * Non parent abstract type.
 519          *
 520          * @throws UnsupportedEncodingException the unsupported encoding exception
 521          * @throws AAIException the AAI exception
 522          */
 523         @Test
 524     public void nonParentAbstractType() throws UnsupportedEncodingException, AAIException {
 525                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers/pserver/key2/vnf/key1").build();
 526                 thrown.expect(AAIException.class);
 527                 thrown.expectMessage(containsString("not a valid path"));
 528                 dbEngine.getQueryBuilder().createQueryFromURI(uri);
 529     }
 530
 531         @Test
 532         public void parentAbstractTypeWithNesting() throws UnsupportedEncodingException, AAIException {
 533                 URI uri = UriBuilder.fromPath("vnf/key1/vf-modules/vf-module/key2").build();
 534
 535                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 536
 537                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 538                                 .has("vnf-id", "key1").or(
 539                                                 __.has(AAIProperties.NODE_TYPE, "vce"),
 540                                                 __.has(AAIProperties.NODE_TYPE, "vpe"),
 541                                                 __.has(AAIProperties.NODE_TYPE, "generic-vnf"))
 542                                 .filter(x -> true).outE().has("isParent", true).inV().has("vf-module-id", "key2");
 543
 544                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 545                                 .has("vnf-id", "key1").or(
 546                                                 __.has(AAIProperties.NODE_TYPE, "vce"),
 547                                                 __.has(AAIProperties.NODE_TYPE, "vpe"),
 548                                                 __.has(AAIProperties.NODE_TYPE, "generic-vnf"));
 549                 assertEquals(
 550                                 "gremlin query should be " + expected.toString(),
 551                                 expected.toString(),
 552                                 query.getQueryBuilder().getQuery().toString());
 553                 assertEquals(
 554                                 "parent gremlin query should be equal the query for ",
 555                                 expectedParent.toString(),
 556                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 557                 assertEquals(
 558                                 "result type should be vnf",
 559                                 "vnf",
 560                                 query.getParentResultType());
 561                 assertEquals(
 562                                 "result type should be vf-module",
 563                                 "vf-module",
 564                                 query.getResultType());
 565
 566                 assertEquals("dependent",true, query.isDependent());
 567
 568         }
 569
 570         @Test
 571         public void getViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 572                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants/tenant").build();
 573                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 574                 map.putSingle("tenant-n231ame", "Tenant1");
 575                 thrown.expect(AAIException.class);
 576                 thrown.expect(hasProperty("code", is("AAI_3000")));
 577
 578                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 579
 580         }
 581
 582         @Test
 583         public void getPluralViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 584                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants").build();
 585                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 586                 map.putSingle("tenant-n231ame", "Tenant1");
 587                 thrown.expect(AAIException.class);
 588                 thrown.expect(hasProperty("code", is("AAI_3000")));
 589
 590                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 591
 592         }
 593
 594         @Test
 595         public void getPluralViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 596                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 597                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 598                 List<String> values = new ArrayList<>();
 599                 values.add("up");
 600                 values.add("down");
 601                 values.add("left");
 602                 values.add("right");
 603                 values.add("start");
 604                 map.put("prov-status", values);
 605                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 606                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 607                                 .has("aai-node-type", "vnfc")
 608                                 .has("prov-status", P.within(values));
 609
 610                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 611                                 .has("aai-node-type", "vnfc");
 612
 613                 assertEquals(
 614                                 "gremlin query should be " + expected.toString(),
 615                                 expected.toString(),
 616                                 query.getQueryBuilder().getQuery().toString());
 617                 assertEquals(
 618                                 "parent",
 619                                 expectedParent.toString(),
 620                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 621                 assertEquals(
 622                                 "parent result type should be empty",
 623                                 "",
 624                                 query.getParentResultType());
 625                 assertEquals(
 626                                 "result type should be vnfc",
 627                                 "vnfc",
 628                                 query.getResultType());
 629                 assertEquals(
 630                                 "container type should be empty",
 631                                 "vnfcs",
 632                                 query.getContainerType());
 633                 assertEquals("dependent",true, query.isDependent());
 634
 635         }
 636
 637         @Test
 638         public void dbAliasedSearch() throws UnsupportedEncodingException, AAIException {
 639                 URI uri = UriBuilder.fromPath("network/test-objects").build();
 640                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 641                 map.putSingle("persona-model-customization-id", "key2");
 642                 QueryParser query = dbEnginev9.getQueryBuilder().createQueryFromURI(uri, map);
 643                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 644                                 .has("aai-node-type", "test-object")
 645                                 .has("model-customization-id", "key2");
 646                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 647                                 .has("aai-node-type", "test-object");
 648
 649                 assertEquals(
 650                                 "gremlin query should be " + expected.toString(),
 651                                 expected.toString(),
 652                                 query.getQueryBuilder().getQuery().toString());
 653                 assertEquals(
 654                                 "parent",
 655                                 expectedParent.toString(),
 656                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 657
 658                 assertEquals(
 659                                 "result type should be",
 660                                 "test-object",
 661                                 query.getResultType());
 662                 assertEquals(
 663                                 "result type should be empty",
 664                                 "",
 665                                 query.getParentResultType());
 666                 assertEquals("dependent",true, query.isDependent());
 667
 668
 669         }
 670
 671         @Test
 672         public void dataLinkedSearch() throws UnsupportedEncodingException, AAIException {
 673                 URI uri = UriBuilder.fromPath("network/vpn-bindings").build();
 674                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 675                 map.putSingle("global-route-target", "key2");
 676                 QueryParser query = dbEnginev9.getQueryBuilder().createQueryFromURI(uri, map);
 677                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 678                                 .has("aai-node-type", "vpn-binding")
 679                                 .where(__.out("has").has(AAIProperties.NODE_TYPE, "route-target").has("global-route-target", "key2"));
 680                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 681                                 .has("aai-node-type", "vpn-binding");
 682
 683                 assertEquals(
 684                                 "gremlin query should be " + expected.toString(),
 685                                 expected.toString(),
 686                                 query.getQueryBuilder().getQuery().toString());
 687                 assertEquals(
 688                                 "parent",
 689                                 expectedParent.toString(),
 690                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 691
 692                 assertEquals(
 693                                 "result type should be",
 694                                 "vpn-binding",
 695                                 query.getResultType());
 696                 assertEquals(
 697                                 "result type should be empty",
 698                                 "",
 699                                 query.getParentResultType());
 700                 assertEquals("dependent",true, query.isDependent());
 701
 702
 703         }
 704 }