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

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.aai.parsers.query;
  21
  22 import org.apache.tinkerpop.gremlin.process.traversal.P;
  23 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  24 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  25 import org.apache.tinkerpop.gremlin.structure.Vertex;
  26 import org.junit.Before;
  27 import org.junit.Rule;
  28 import org.junit.Test;
  29 import org.junit.rules.ExpectedException;
  30 import org.junit.runner.RunWith;
  31 import org.junit.runners.Parameterized;
  32 import org.onap.aai.AAISetup;
  33 import org.onap.aai.DataLinkSetup;
  34 import org.onap.aai.db.props.AAIProperties;
  35 import org.onap.aai.exceptions.AAIException;
  36 import org.onap.aai.introspection.ModelType;
  37 import org.onap.aai.rest.RestTokens;
  38 import org.onap.aai.serialization.engines.QueryStyle;
  39 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  40 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  41 import org.springframework.test.annotation.DirtiesContext;
  42
  43 import javax.ws.rs.core.MultivaluedHashMap;
  44 import javax.ws.rs.core.MultivaluedMap;
  45 import javax.ws.rs.core.UriBuilder;
  46 import java.io.UnsupportedEncodingException;
  47 import java.net.URI;
  48 import java.util.ArrayList;
  49 import java.util.Arrays;
  50 import java.util.Collection;
  51 import java.util.List;
  52
  53 import static org.hamcrest.CoreMatchers.containsString;
  54 import static org.hamcrest.Matchers.hasProperty;
  55 import static org.hamcrest.Matchers.is;
  56 import static org.junit.Assert.assertEquals;
  57
  58 @RunWith(value = Parameterized.class)
  59 @DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
  60 public class GraphTraversalTest extends DataLinkSetup {
  61
  62     private TransactionalGraphEngine dbEngine;
  63     private TransactionalGraphEngine dbEngineDepthVersion;
  64
  65     @Parameterized.Parameter(value = 0)
  66     public QueryStyle queryStyle;
  67
  68     @Parameterized.Parameters(name = "QueryStyle.{0}")
  69     public static Collection<Object[]> data() {
  70         return Arrays.asList(new Object[][]{
  71                 {QueryStyle.TRAVERSAL},
  72                 {QueryStyle.TRAVERSAL_URI}
  73         });
  74     }
  75
  76     @Rule public ExpectedException thrown = ExpectedException.none();
  77
  78
  79     /**
  80      * Configure.
  81      * @throws Exception
  82      * @throws SecurityException
  83      * @throws NoSuchFieldException
  84      */
  85     @Before
  86     public void configure() throws Exception {
  87         dbEngine =
  88                 new JanusGraphDBEngine(queryStyle,
  89                     loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion()),
  90                     false);
  91
  92         dbEngineDepthVersion =
  93                 new JanusGraphDBEngine(queryStyle,
  94                     loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDepthVersion()),
  95                     false);
  96     }
  97
  98     /**
  99      * Parent query.
 100      *
 101      * @throws UnsupportedEncodingException the unsupported encoding exception
 102      * @throws AAIException the AAI exception
 103      */
 104     @Test
 105     public void parentQuery() throws UnsupportedEncodingException, AAIException {
 106         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1").build();
 107
 108         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 109
 110         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start().has("physical-location-id", "key1").has("aai-node-type", "complex");
 111         assertEquals(
 112                 "gremlin query should be " + expected.toString(),
 113                 expected.toString(),
 114                 query.getQueryBuilder().getQuery().toString());
 115         assertEquals(
 116                 "parent gremlin query should be equal to normal query",
 117                 expected.toString(),
 118                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 119         assertEquals(
 120                 "result type should be complex",
 121                 "complex",
 122                 query.getResultType());
 123         assertEquals(
 124                 "result type should be empty",
 125                 "",
 126                 query.getParentResultType());
 127         assertEquals("dependent",false, query.isDependent());
 128
 129
 130     }
 131
 132     /**
 133      * Child query.
 134      *
 135      * @throws UnsupportedEncodingException the unsupported encoding exception
 136      * @throws AAIException the AAI exception
 137      */
 138     @Test
 139     public void childQuery() throws UnsupportedEncodingException, AAIException {
 140         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/ctag-pools/ctag-pool/key2/key3").build();
 141         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 142         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 143                 .has("physical-location-id", "key1").has("aai-node-type", "complex")
 144                 .in("org.onap.relationships.inventory.BelongsTo")
 145                 .has("aai-node-type", "ctag-pool")
 146                 .has("target-pe", "key2").has("availability-zone-name", "key3");
 147         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 148                 .has("physical-location-id", "key1").has("aai-node-type", "complex");
 149         assertEquals(
 150                 "gremlin query should be " + expected.toString(),
 151                 expected.toString(),
 152                 query.getQueryBuilder().getQuery().toString());
 153         assertEquals(
 154                 "parent gremlin query should be equal the query for complex",
 155                 expectedParent.toString(),
 156                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 157         assertEquals(
 158                 "result type should be complex",
 159                 "complex",
 160                 query.getParentResultType());
 161         assertEquals(
 162                 "result type should be ctag-pool",
 163                 "ctag-pool",
 164                 query.getResultType());
 165         assertEquals("dependent",true, query.isDependent());
 166
 167
 168     }
 169
 170     /**
 171      * Naming exceptions.
 172      *
 173      * @throws UnsupportedEncodingException the unsupported encoding exception
 174      * @throws AAIException the AAI exception
 175      */
 176     @Test
 177     public void namingExceptions() throws UnsupportedEncodingException, AAIException {
 178         URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags/cvlan-tag/655").build();
 179         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 180         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 181                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 182                 .in("org.onap.relationships.inventory.BelongsTo")
 183                 .has("aai-node-type", "port-group")
 184                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 185                 .has("aai-node-type", "cvlan-tag")
 186                 .has("cvlan-tag", 655);
 187         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 188                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 189                 .in("org.onap.relationships.inventory.BelongsTo")
 190                 .has("aai-node-type", "port-group")
 191                 .has("interface-id", "key2");
 192         assertEquals(
 193                 "gremlin query should be " + expected.toString(),
 194                 expected.toString(),
 195                 query.getQueryBuilder().getQuery().toString());
 196         assertEquals(
 197                 "parent gremlin query should be equal the query for port group",
 198                 expectedParent.toString(),
 199                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 200         assertEquals(
 201                 "result type should be cvlan-tag",
 202                 "cvlan-tag",
 203                 query.getResultType());
 204         assertEquals(
 205                 "result type should be port-group",
 206                 "port-group",
 207                 query.getParentResultType());
 208         assertEquals(
 209                 "contaner type should be empty",
 210                 "",
 211                 query.getContainerType());
 212         assertEquals("dependent",true, query.isDependent());
 213
 214
 215     }
 216
 217     /**
 218      * Gets the all.
 219      *
 220      * @return the all
 221      * @throws UnsupportedEncodingException the unsupported encoding exception
 222      * @throws AAIException the AAI exception
 223      */
 224     @Test
 225     public void getAll() throws UnsupportedEncodingException, AAIException {
 226         URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 227         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 228         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 229                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 230                 .in("org.onap.relationships.inventory.BelongsTo")
 231                 .has("aai-node-type", "port-group")
 232                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 233                 .has("aai-node-type", "cvlan-tag");
 234         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 235                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 236                 .in("org.onap.relationships.inventory.BelongsTo")
 237                 .has("aai-node-type", "port-group")
 238                 .has("interface-id", "key2");
 239         assertEquals(
 240                 "gremlin query should be " + expected.toString(),
 241                 expected.toString(),
 242                 query.getQueryBuilder().getQuery().toString());
 243         assertEquals(
 244                 "parent gremlin query should be equal the query for port group",
 245                 expectedParent.toString(),
 246                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 247         assertEquals(
 248                 "result type should be port-group",
 249                 "port-group",
 250                 query.getParentResultType());
 251         assertEquals(
 252                 "result type should be cvlan-tag",
 253                 "cvlan-tag",
 254                 query.getResultType());
 255         assertEquals(
 256                 "container type should be cvlan-tags",
 257                 "cvlan-tags",
 258                 query.getContainerType());
 259         assertEquals("dependent",true, query.isDependent());
 260
 261
 262     }
 263
 264     @Test
 265     public void getAllParent() throws UnsupportedEncodingException, AAIException {
 266         URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers").build();
 267         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 268         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 269                 .has("aai-node-type", "pserver");
 270         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 271                 .has("aai-node-type", "pserver");
 272         assertEquals(
 273                 "gremlin query should be " + expected.toString(),
 274                 expected.toString(),
 275                 query.getQueryBuilder().getQuery().toString());
 276         assertEquals(
 277                 "parent gremlin query should be equal the query for pserver",
 278                 expectedParent.toString(),
 279                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 280         assertEquals(
 281                 "parent result type should be empty",
 282                 "",
 283                 query.getParentResultType());
 284         assertEquals(
 285                 "result type should be pserver",
 286                 "pserver",
 287                 query.getResultType());
 288         assertEquals(
 289                 "container type should be pservers",
 290                 "pservers",
 291                 query.getContainerType());
 292         assertEquals("dependent",false, query.isDependent());
 293
 294
 295     }
 296
 297
 298     /**
 299      * Gets the via query param.
 300      *
 301      * @return the via query param
 302      * @throws UnsupportedEncodingException the unsupported encoding exception
 303      * @throws AAIException the AAI exception
 304      */
 305     @Test
 306     public void getViaQueryParam() throws UnsupportedEncodingException, AAIException {
 307         URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 308         MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 309         map.putSingle("tenant-name", "Tenant1");
 310         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 311         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 312                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 313                 .has("aai-node-type", "cloud-region")
 314                 .in("org.onap.relationships.inventory.BelongsTo")
 315                 .has("aai-node-type", "tenant")
 316                 .has("tenant-name", "Tenant1");
 317
 318         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 319                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 320                 .has("aai-node-type", "cloud-region");
 321
 322         assertEquals(
 323                 "gremlin query should be " + expected.toString(),
 324                 expected.toString(),
 325                 query.getQueryBuilder().getQuery().toString());
 326         assertEquals(
 327                 "parent gremlin query should be equal the query for cloud-region",
 328                 expectedParent.toString(),
 329                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 330         assertEquals(
 331                 "result type should be cloud-region",
 332                 "cloud-region",
 333                 query.getParentResultType());
 334         assertEquals(
 335                 "result type should be tenant",
 336                 "tenant",
 337                 query.getResultType());
 338         assertEquals(
 339                 "container type should be empty",
 340                 "",
 341                 query.getContainerType());
 342         assertEquals("dependent",true, query.isDependent());
 343
 344     }
 345
 346     @Test
 347     public void getViaDuplicateQueryParam() throws UnsupportedEncodingException, AAIException {
 348         URI uri = UriBuilder.fromPath("cloud-infrastructure/cloud-regions/cloud-region/mycloudowner/mycloudregionid/tenants/tenant").build();
 349         MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 350         List<String> values = new ArrayList<>();
 351         values.add("Tenant1");
 352         values.add("Tenant2");
 353         map.put("tenant-name", values);
 354         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 355         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 356                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 357                 .has("aai-node-type", "cloud-region")
 358                 .in("org.onap.relationships.inventory.BelongsTo")
 359                 .has("aai-node-type", "tenant")
 360                 .has("tenant-name", P.within(values));
 361
 362         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 363                 .has("cloud-owner", "mycloudowner").has("cloud-region-id", "mycloudregionid")
 364                 .has("aai-node-type", "cloud-region");
 365
 366         assertEquals(
 367                 "gremlin query should be " + expected.toString(),
 368                 expected.toString(),
 369                 query.getQueryBuilder().getQuery().toString());
 370         assertEquals(
 371                 "parent gremlin query should be equal the query for cloud-region",
 372                 expectedParent.toString(),
 373                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 374         assertEquals(
 375                 "result type should be cloud-region",
 376                 "cloud-region",
 377                 query.getParentResultType());
 378         assertEquals(
 379                 "result type should be tenant",
 380                 "tenant",
 381                 query.getResultType());
 382         assertEquals(
 383                 "container type should be empty",
 384                 "",
 385                 query.getContainerType());
 386         assertEquals("dependent",true, query.isDependent());
 387
 388     }
 389
 390     /**
 391      * Gets the plural via query param.
 392      *
 393      * @return the plural via query param
 394      * @throws UnsupportedEncodingException the unsupported encoding exception
 395      * @throws AAIException the AAI exception
 396      */
 397     @Test
 398     public void getPluralViaQueryParam() throws UnsupportedEncodingException, AAIException {
 399         URI uri = UriBuilder.fromPath("network/vnfcs").build();
 400         MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 401         map.putSingle("prov-status", "up");
 402         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 403         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 404                 .has("aai-node-type", "vnfc")
 405                 .has("prov-status", "up");
 406
 407         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 408                 .has("aai-node-type", "vnfc");
 409
 410         assertEquals(
 411                 "gremlin query should be " + expected.toString(),
 412                 expected.toString(),
 413                 query.getQueryBuilder().getQuery().toString());
 414         assertEquals(
 415                 "parent",
 416                 expectedParent.toString(),
 417                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 418         assertEquals(
 419                 "parent result type should be empty",
 420                 "",
 421                 query.getParentResultType());
 422         assertEquals(
 423                 "result type should be vnfc",
 424                 "vnfc",
 425                 query.getResultType());
 426         assertEquals(
 427                 "container type should be empty",
 428                 "vnfcs",
 429                 query.getContainerType());
 430         assertEquals("dependent",true, query.isDependent());
 431
 432     }
 433
 434     /**
 435      * Gets the all query param naming exception.
 436      *
 437      * @return the all query param naming exception
 438      * @throws UnsupportedEncodingException the unsupported encoding exception
 439      * @throws AAIException the AAI exception
 440      */
 441     @Test
 442     public void getAllQueryParamNamingException() throws UnsupportedEncodingException, AAIException {
 443         URI uri = UriBuilder.fromPath("network/vces/vce/key1/port-groups/port-group/key2/cvlan-tags").build();
 444         MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 445         map.putSingle("cvlan-tag", "333");
 446         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri, map);
 447
 448         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 449                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 450                 .in("org.onap.relationships.inventory.BelongsTo")
 451                 .has("aai-node-type", "port-group")
 452                 .has("interface-id", "key2").in("org.onap.relationships.inventory.BelongsTo")
 453                 .has("aai-node-type", "cvlan-tag")
 454                 .has("cvlan-tag", 333);
 455         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 456                 .has("vnf-id", "key1").has("aai-node-type", "vce")
 457                 .in("org.onap.relationships.inventory.BelongsTo")
 458                 .has("aai-node-type", "port-group")
 459                 .has("interface-id", "key2");
 460         assertEquals(
 461                 "gremlin query should be " + expected.toString(),
 462                 expected.toString(),
 463                 query.getQueryBuilder().getQuery().toString());
 464         assertEquals(
 465                 "parent gremlin query should be equal the query for port group",
 466                 expectedParent.toString(),
 467                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 468         assertEquals(
 469                 "result type should be port-group",
 470                 "port-group",
 471                 query.getParentResultType());
 472         assertEquals(
 473                 "result type should be cvlan-tag",
 474                 "cvlan-tag",
 475                 query.getResultType());
 476         assertEquals(
 477                 "container type should be cvlan-tags",
 478                 "cvlan-tags",
 479                 query.getContainerType());
 480         assertEquals("dependent",true, query.isDependent());
 481
 482
 483     }
 484
 485     /**
 486      * Abstract type.
 487      *
 488      * @throws UnsupportedEncodingException the unsupported encoding exception
 489      * @throws AAIException the AAI exception
 490      */
 491     @Test
 492     public void abstractType() throws UnsupportedEncodingException, AAIException {
 493         URI uri = UriBuilder.fromPath("vnf/key1").build();
 494
 495         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 496
 497         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 498                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "generic-vnf"));
 499
 500         GraphTraversal<Vertex, Vertex> expectedParent = expected;
 501         assertEquals(
 502                 "gremlin query should be " + expected.toString(),
 503                 expected.toString(),
 504                 query.getQueryBuilder().getQuery().toString());
 505         assertEquals(
 506                 "parent gremlin query should be equal the query for port group",
 507                 expectedParent.toString(),
 508                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 509         assertEquals(
 510                 "result type should be empty",
 511                 "",
 512                 query.getParentResultType());
 513         assertEquals(
 514                 "result type should be vnf",
 515                 "vnf",
 516                 query.getResultType());
 517
 518         assertEquals("dependent",false, query.isDependent());
 519
 520
 521     }
 522
 523     /**
 524      * Non parent abstract type.
 525      *
 526      * @throws UnsupportedEncodingException the unsupported encoding exception
 527      * @throws AAIException the AAI exception
 528      */
 529     @Test
 530     public void nonParentAbstractType() throws UnsupportedEncodingException, AAIException {
 531         URI uri = UriBuilder.fromPath("cloud-infrastructure/pservers/pserver/key2/vnf/key1").build();
 532         thrown.expect(AAIException.class);
 533         thrown.expectMessage(containsString("not a valid path"));
 534         dbEngine.getQueryBuilder().createQueryFromURI(uri);
 535     }
 536
 537     @Test
 538     public void parentAbstractTypeWithNesting() throws UnsupportedEncodingException, AAIException {
 539         URI uri = UriBuilder.fromPath("vnf/key1/vf-modules/vf-module/key2").build();
 540
 541         QueryParser query = dbEngine.getQueryBuilder().createQueryFromURI(uri);
 542
 543         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 544                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "generic-vnf"))
 545                 .union(__.in("org.onap.relationships.inventory.BelongsTo").has(AAIProperties.NODE_TYPE, "vf-module")).has("vf-module-id", "key2");
 546
 547         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 548                 .has("vnf-id", "key1").has(AAIProperties.NODE_TYPE, P.within("vce", "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/generic-vnfs").build();
 640         MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
 641         map.putSingle("persona-model-customization-id", "key2");
 642         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri, map);
 643         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 644                 .has("aai-node-type", "generic-vnf")
 645                 .has("model-customization-id", "key2");
 646         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 647                 .has("aai-node-type", "generic-vnf");
 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                 "generic-vnf",
 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 = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri, map);
 677         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 678                 .has("aai-node-type", "vpn-binding")
 679                 .where(__.in("org.onap.relationships.inventory.BelongsTo").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     @Test
 704     public void pluralCousin() throws UnsupportedEncodingException, AAIException {
 705         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers").build();
 706
 707         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 708         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 709                 .has("physical-location-id", "key1")
 710                 .has("aai-node-type", "complex")
 711                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver");
 712         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 713                 .has("physical-location-id", "key1")
 714                 .has("aai-node-type", "complex");
 715
 716         assertEquals(
 717                 "gremlin query should be " + expected.toString(),
 718                 expected.toString(),
 719                 query.getQueryBuilder().getQuery().toString());
 720         assertEquals(
 721                 "parent",
 722                 expectedParent.toString(),
 723                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 724
 725         assertEquals(
 726                 "result type should be",
 727                 "pserver",
 728                 query.getResultType());
 729         assertEquals(
 730                 "result type should be",
 731                 "complex",
 732                 query.getParentResultType());
 733         //this is controversial but we're not allowing writes on this currently
 734         assertEquals("dependent",true, query.isDependent());
 735     }
 736
 737     @Test
 738     public void specificCousin() throws UnsupportedEncodingException, AAIException {
 739         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers/pserver/key2").build();
 740
 741         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 742         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 743                 .has("physical-location-id", "key1")
 744                 .has("aai-node-type", "complex")
 745                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 746                 .has("hostname", "key2");
 747         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 748                 .has("physical-location-id", "key1")
 749                 .has("aai-node-type", "complex");
 750
 751         assertEquals(
 752                 "gremlin query should be " + expected.toString(),
 753                 expected.toString(),
 754                 query.getQueryBuilder().getQuery().toString());
 755         assertEquals(
 756                 "parent",
 757                 expectedParent.toString(),
 758                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 759
 760         assertEquals(
 761                 "result type should be",
 762                 "pserver",
 763                 query.getResultType());
 764         assertEquals(
 765                 "result type should be",
 766                 "complex",
 767                 query.getParentResultType());
 768         //this is controversial but we're not allowing writes on this currently
 769         assertEquals("dependent",true, query.isDependent());
 770     }
 771
 772     @Test
 773     public void doubleSpecificCousin() throws UnsupportedEncodingException, AAIException {
 774         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to/pservers/pserver/key2/related-to/vservers/vserver/key3").build();
 775
 776         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 777         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start()
 778                 .has("physical-location-id", "key1")
 779                 .has("aai-node-type", "complex")
 780                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 781                 .has("hostname", "key2")
 782                 .in("tosca.relationships.HostedOn").has("aai-node-type", "vserver")
 783                 .has("vserver-id", "key3");
 784         GraphTraversal<Vertex, Vertex> expectedParent = __.<Vertex>start()
 785                 .has("physical-location-id", "key1")
 786                 .has("aai-node-type", "complex")
 787                 .in("org.onap.relationships.inventory.LocatedIn").has("aai-node-type", "pserver")
 788                 .has("hostname", "key2");
 789
 790         assertEquals(
 791                 "gremlin query should be " + expected.toString(),
 792                 expected.toString(),
 793                 query.getQueryBuilder().getQuery().toString());
 794         assertEquals(
 795                 "parent",
 796                 expectedParent.toString(),
 797                 query.getQueryBuilder().getParentQuery().getQuery().toString());
 798
 799         assertEquals(
 800                 "result type should be",
 801                 "vserver",
 802                 query.getResultType());
 803         assertEquals(
 804                 "result type should be",
 805                 "pserver",
 806                 query.getParentResultType());
 807         //this is controversial but we're not allowing writes on this currently
 808         assertEquals("dependent",true, query.isDependent());
 809     }
 810
 811     @Test
 812     public void traversalEndsInRelatedTo() throws UnsupportedEncodingException, AAIException {
 813         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/complex/key1/related-to").build();
 814
 815         thrown.expect(AAIException.class);
 816         thrown.expectMessage(containsString(RestTokens.COUSIN.toString()));
 817         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 818
 819     }
 820
 821     @Test
 822     public void pluralCousinToPluralCousin() throws UnsupportedEncodingException, AAIException {
 823         URI uri = UriBuilder.fromPath("cloud-infrastructure/complexes/related-to/pservers").build();
 824
 825         thrown.expect(AAIException.class);
 826         thrown.expectMessage(containsString("chain plurals"));
 827         QueryParser query = dbEngineDepthVersion.getQueryBuilder().createQueryFromURI(uri);
 828
 829     }
 830 }