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

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