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").has(
 490                                                 AAIProperties.NODE_TYPE, P.within("vce" , "vpe" , "generic-vnf"));
 491
 492                 GraphTraversal<Vertex, Vertex> expectedParent = expected;
 493                 assertEquals(
 494                                 "gremlin query should be " + expected.toString(),
 495                                 expected.toString(),
 496                                 query.getQueryBuilder().getQuery().toString());
 497                 assertEquals(
 498                                 "parent gremlin query should be equal the query for port group",
 499                                 expectedParent.toString(),
 500                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 501                 assertEquals(
 502                                 "result type should be empty",
 503                                 "",
 504                                 query.getParentResultType());
 505                 assertEquals(
 506                                 "result type should be vnf",
 507                                 "vnf",
 508                                 query.getResultType());
 509
 510                 assertEquals("dependent",false, query.isDependent());
 511
 512
 513     }
 514
 515         /**
 516          * Non parent abstract type.
 517          *
 518          * @throws UnsupportedEncodingException the unsupported encoding exception
 519          * @throws AAIException the AAI exception
 520          */
 521         @Test
 522     public void nonParentAbstractType() throws UnsupportedEncodingException, AAIException {
 523                 URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers/pserver/key2/vnf/key1").build();
 524                 thrown.expect(AAIException.class);
 525                 thrown.expectMessage(containsString("not a valid path"));
 526                 dbEngine.getQueryBuilder().createQueryFromURI(uri);
 527     }
 528
 529         @Test
 530         public void parentAbstractTypeWithNesting() throws UnsupportedEncodingException, AAIException {
 531                 URI uri = UriBuilder.fromPath("vnf/key1/vf-modules/vf-module/key2").build();
 532
 533                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 534
 535                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 536                                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "vpe", "generic-vnf"))
 537                 .union(__.out("has").has("aai-node-type", "vf-module"))
 538                                 .has("vf-module-id", "key2");
 539
 540                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 541                                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "vpe", "generic-vnf"));
 542                 assertEquals(
 543                                 "gremlin query should be " + expected.toString(),
 544                                 expected.toString(),
 545                                 query.getQueryBuilder().getQuery().toString());
 546                 assertEquals(
 547                                 "parent gremlin query should be equal the query for ",
 548                                 expectedParent.toString(),
 549                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 550                 assertEquals(
 551                                 "result type should be vnf",
 552                                 "vnf",
 553                                 query.getParentResultType());
 554                 assertEquals(
 555                                 "result type should be vf-module",
 556                                 "vf-module",
 557                                 query.getResultType());
 558
 559                 assertEquals("dependent",true, query.isDependent());
 560
 561         }
 562
 563         @Test
 564         public void getViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 565                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants/tenant").build();
 566                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 567                 map.putSingle("tenant-n231ame", "Tenant1");
 568                 thrown.expect(AAIException.class);
 569                 thrown.expect(hasProperty("code", is("AAI_3000")));
 570
 571                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 572
 573         }
 574
 575         @Test
 576         public void getPluralViaBadQueryParam() throws UnsupportedEncodingException, AAIException {
 577                 URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/a/b/tenants").build();
 578                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 579                 map.putSingle("tenant-n231ame", "Tenant1");
 580                 thrown.expect(AAIException.class);
 581                 thrown.expect(hasProperty("code", is("AAI_3000")));
 582
 583                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 584
 585         }
 586
 587         @Test
 588         public void getPluralViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 589                 URI uri = UriBuilder.fromPath("network/vnfcs").build();
 590                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 591                 List<String> values = new ArrayList<>();
 592                 values.add("up");
 593                 values.add("down");
 594                 values.add("left");
 595                 values.add("right");
 596                 values.add("start");
 597                 map.put("prov-status", values);
 598                 QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 599                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 600                                 .has("aai-node-type", "vnfc")
 601                                 .has("prov-status", P.within(values));
 602
 603                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 604                                 .has("aai-node-type", "vnfc");
 605
 606                 assertEquals(
 607                                 "gremlin query should be " + expected.toString(),
 608                                 expected.toString(),
 609                                 query.getQueryBuilder().getQuery().toString());
 610                 assertEquals(
 611                                 "parent",
 612                                 expectedParent.toString(),
 613                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 614                 assertEquals(
 615                                 "parent result type should be empty",
 616                                 "",
 617                                 query.getParentResultType());
 618                 assertEquals(
 619                                 "result type should be vnfc",
 620                                 "vnfc",
 621                                 query.getResultType());
 622                 assertEquals(
 623                                 "container type should be empty",
 624                                 "vnfcs",
 625                                 query.getContainerType());
 626                 assertEquals("dependent",true, query.isDependent());
 627
 628         }
 629
 630         @Test
 631         public void dbAliasedSearch() throws UnsupportedEncodingException, AAIException {
 632                 URI uri = UriBuilder.fromPath("network/test-objects").build();
 633                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 634                 map.putSingle("persona-model-customization-id", "key2");
 635                 QueryParser query = dbEnginev9.getQueryBuilder().createQueryFromURI(uri, map);
 636                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 637                                 .has("aai-node-type", "test-object")
 638                                 .has("model-customization-id", "key2");
 639                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 640                                 .has("aai-node-type", "test-object");
 641
 642                 assertEquals(
 643                                 "gremlin query should be " + expected.toString(),
 644                                 expected.toString(),
 645                                 query.getQueryBuilder().getQuery().toString());
 646                 assertEquals(
 647                                 "parent",
 648                                 expectedParent.toString(),
 649                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 650
 651                 assertEquals(
 652                                 "result type should be",
 653                                 "test-object",
 654                                 query.getResultType());
 655                 assertEquals(
 656                                 "result type should be empty",
 657                                 "",
 658                                 query.getParentResultType());
 659                 assertEquals("dependent",true, query.isDependent());
 660
 661
 662         }
 663
 664         @Test
 665         public void dataLinkedSearch() throws UnsupportedEncodingException, AAIException {
 666                 URI uri = UriBuilder.fromPath("network/vpn-bindings").build();
 667                 MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 668                 map.putSingle("global-route-target", "key2");
 669                 QueryParser query = dbEnginev9.getQueryBuilder().createQueryFromURI(uri, map);
 670                 GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 671                                 .has("aai-node-type", "vpn-binding")
 672                                 .where(__.out("has").has(AAIProperties.NODE_TYPE, "route-target").has("global-route-target", "key2"));
 673                 GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 674                                 .has("aai-node-type", "vpn-binding");
 675
 676                 assertEquals(
 677                                 "gremlin query should be " + expected.toString(),
 678                                 expected.toString(),
 679                                 query.getQueryBuilder().getQuery().toString());
 680                 assertEquals(
 681                                 "parent",
 682                                 expectedParent.toString(),
 683                                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 684
 685                 assertEquals(
 686                                 "result type should be",
 687                                 "vpn-binding",
 688                                 query.getResultType());
 689                 assertEquals(
 690                                 "result type should be empty",
 691                                 "",
 692                                 query.getParentResultType());
 693                 assertEquals("dependent",true, query.isDependent());
 694
 695
 696         }
 697 }