mso-catalog-db/src/test/java/org/openecomp/mso/db/catalog/test/CatalogDatabaseTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 Huawei Technologies Co., Ltd. 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.mso.db.catalog.test;
  22
  23 import mockit.Mock;
  24 import mockit.MockUp;
  25 import org.hibernate.HibernateException;
  26 import org.hibernate.NonUniqueResultException;
  27 import org.hibernate.Query;
  28 import org.hibernate.Session;
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.openecomp.mso.db.catalog.CatalogDatabase;
  32 import org.openecomp.mso.db.catalog.beans.AllottedResource;
  33 import org.openecomp.mso.db.catalog.beans.AllottedResourceCustomization;
  34 import org.openecomp.mso.db.catalog.beans.HeatEnvironment;
  35 import org.openecomp.mso.db.catalog.beans.HeatFiles;
  36 import org.openecomp.mso.db.catalog.beans.HeatTemplate;
  37 import org.openecomp.mso.db.catalog.beans.HeatTemplateParam;
  38 import org.openecomp.mso.db.catalog.beans.NetworkResource;
  39 import org.openecomp.mso.db.catalog.beans.NetworkResourceCustomization;
  40 import org.openecomp.mso.db.catalog.beans.Service;
  41 import org.openecomp.mso.db.catalog.beans.ServiceRecipe;
  42 import org.openecomp.mso.db.catalog.beans.ServiceToResourceCustomization;
  43 import org.openecomp.mso.db.catalog.beans.TempNetworkHeatTemplateLookup;
  44 import org.openecomp.mso.db.catalog.beans.ToscaCsar;
  45 import org.openecomp.mso.db.catalog.beans.VfModule;
  46 import org.openecomp.mso.db.catalog.beans.VfModuleCustomization;
  47 import org.openecomp.mso.db.catalog.beans.VfModuleToHeatFiles;
  48 import org.openecomp.mso.db.catalog.beans.VnfComponent;
  49 import org.openecomp.mso.db.catalog.beans.VnfComponentsRecipe;
  50 import org.openecomp.mso.db.catalog.beans.VnfRecipe;
  51 import org.openecomp.mso.db.catalog.beans.VnfResource;
  52 import org.openecomp.mso.db.catalog.beans.VnfResourceCustomization;
  53 import org.openecomp.mso.db.catalog.utils.RecordNotFoundException;
  54
  55 import java.io.Serializable;
  56 import java.util.*;
  57
  58 import static org.junit.Assert.assertEquals;
  59 import static org.junit.Assert.assertFalse;
  60
  61 public class CatalogDatabaseTest {
  62
  63     CatalogDatabase cd = null;
  64
  65     @Before
  66     public void setup(){
  67         cd = CatalogDatabase.getInstance();
  68     }
  69
  70
  71     @Test
  72     public void getAllHeatTemplatesTest(){
  73
  74         MockUp<Query> mockUpQuery = new MockUp<Query>() {
  75             @Mock
  76             public List<HeatTemplate> list() {
  77                 HeatTemplate heatTemplate = new HeatTemplate();
  78                 return Arrays.asList(heatTemplate);
  79             }
  80         };
  81
  82         MockUp<Session> mockedSession = new MockUp<Session>() {
  83             @Mock
  84             public Query createQuery(String hql) {
  85                 return mockUpQuery.getMockInstance();
  86             }
  87         };
  88
  89         new MockUp<CatalogDatabase>() {
  90             @Mock
  91             private Session getSession() {
  92                 return mockedSession.getMockInstance();
  93             }
  94         };
  95
  96         List <HeatTemplate> list = cd.getAllHeatTemplates();
  97         assertEquals(list.size(), 1);
  98     }
  99
 100     @Test
 101     public void getHeatTemplateByIdTest(){
 102
 103         MockUp<Session> mockedSession = new MockUp<Session>() {
 104             @Mock
 105             public Object get(Class cls, Serializable id) {
 106                 HeatTemplate heatTemplate = new HeatTemplate();
 107                 heatTemplate.setAsdcUuid("123-uuid");
 108                 return heatTemplate;
 109             }
 110         };
 111
 112         new MockUp<CatalogDatabase>() {
 113             @Mock
 114             private Session getSession() {
 115                 return mockedSession.getMockInstance();
 116             }
 117         };
 118
 119         HeatTemplate ht = cd.getHeatTemplate(10);
 120         assertEquals("123-uuid", ht.getAsdcUuid());
 121     }
 122
 123     @Test
 124     public void getHeatTemplateByNameEmptyListTest(){
 125
 126         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 127             @Mock
 128             public List<HeatTemplate> list() {
 129                 HeatTemplate heatTemplate = new HeatTemplate();
 130                 return Arrays.asList();
 131             }
 132         };
 133
 134         MockUp<Session> mockedSession = new MockUp<Session>() {
 135             @Mock
 136             public Query createQuery(String hql) {
 137                 return mockUpQuery.getMockInstance();
 138             }
 139         };
 140
 141         new MockUp<CatalogDatabase>() {
 142             @Mock
 143             private Session getSession() {
 144                 return mockedSession.getMockInstance();
 145             }
 146         };
 147
 148         HeatTemplate ht = cd.getHeatTemplate("heat123");
 149         assertEquals(null, ht);
 150     }
 151
 152     @Test
 153     public void getHeatTemplateByNameTest(){
 154
 155         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 156             @Mock
 157             public List<HeatTemplate> list() {
 158                 HeatTemplate heatTemplate1 = new HeatTemplate();
 159                 heatTemplate1.setAsdcUuid("123-uuid");
 160                 heatTemplate1.setVersion("1.2");
 161                 HeatTemplate heatTemplate2 = new HeatTemplate();
 162                 heatTemplate2.setAsdcUuid("456-uuid");
 163                 heatTemplate2.setVersion("1.3");
 164                 return Arrays.asList(heatTemplate1, heatTemplate2);
 165             }
 166         };
 167
 168         MockUp<Session> mockedSession = new MockUp<Session>() {
 169             @Mock
 170             public Query createQuery(String hql) {
 171                 return mockUpQuery.getMockInstance();
 172             }
 173         };
 174
 175         new MockUp<CatalogDatabase>() {
 176             @Mock
 177             private Session getSession() {
 178                 return mockedSession.getMockInstance();
 179             }
 180         };
 181
 182         HeatTemplate ht = cd.getHeatTemplate("heat123");
 183         assertEquals("456-uuid", ht.getAsdcUuid());
 184     }
 185
 186     @Test
 187     public void getHeatTemplateByTemplateNameTest() {
 188
 189         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 190             @Mock
 191             public List<HeatTemplate> list() {
 192                 HeatTemplate heatTemplate = new HeatTemplate();
 193                 heatTemplate.setAsdcUuid("1234-uuid");
 194                 return Arrays.asList(heatTemplate);
 195             }
 196         };
 197
 198         MockUp<Session> mockedSession = new MockUp<Session>() {
 199             @Mock
 200             public Query createQuery(String hql) {
 201                 return mockUpQuery.getMockInstance();
 202             }
 203         };
 204
 205         new MockUp<CatalogDatabase>() {
 206             @Mock
 207             private Session getSession() {
 208                 return mockedSession.getMockInstance();
 209             }
 210         };
 211
 212         HeatTemplate ht = cd.getHeatTemplate("heat123","v2");
 213         assertEquals("1234-uuid", ht.getAsdcUuid());
 214     }
 215
 216     @Test
 217     public void getHeatTemplateByTemplateNameEmptyResultTest() {
 218
 219         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 220             @Mock
 221             public List<HeatTemplate> list() {
 222                 return Arrays.asList();
 223             }
 224         };
 225
 226         MockUp<Session> mockedSession = new MockUp<Session>() {
 227             @Mock
 228             public Query createQuery(String hql) {
 229                 return mockUpQuery.getMockInstance();
 230             }
 231         };
 232
 233         new MockUp<CatalogDatabase>() {
 234             @Mock
 235             private Session getSession() {
 236                 return mockedSession.getMockInstance();
 237             }
 238         };
 239
 240         HeatTemplate ht = cd.getHeatTemplate("heat123","v2");
 241         assertEquals(null, ht);
 242     }
 243
 244     @Test
 245     public void getHeatTemplateByArtifactUuidException(){
 246
 247         MockUp<Session> mockedSession = new MockUp<Session>() {
 248             @Mock
 249             public Object get(Class cls, Serializable id) {
 250                 HeatTemplate heatTemplate = new HeatTemplate();
 251                 heatTemplate.setAsdcUuid("123-uuid");
 252                 return heatTemplate;
 253             }
 254         };
 255
 256         new MockUp<CatalogDatabase>() {
 257             @Mock
 258             private Session getSession() {
 259                 return mockedSession.getMockInstance();
 260             }
 261         };
 262
 263         HeatTemplate ht = cd.getHeatTemplateByArtifactUuid("123");
 264         assertEquals("123-uuid", ht.getAsdcUuid());
 265     }
 266
 267     @Test
 268     public void getHeatTemplateByArtifactUuidTest(){
 269
 270         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 271
 272             @Mock
 273             public Object uniqueResult() {
 274                 HeatTemplate heatTemplate = new HeatTemplate();
 275                 heatTemplate.setAsdcUuid("123-uuid");
 276                 return heatTemplate;
 277             }
 278         };
 279
 280         MockUp<Session> mockedSession = new MockUp<Session>() {
 281             @Mock
 282             public Query createQuery(String hql) {
 283                 return mockUpQuery.getMockInstance();
 284             }
 285         };
 286
 287         new MockUp<CatalogDatabase>() {
 288             @Mock
 289             private Session getSession() {
 290                 return mockedSession.getMockInstance();
 291             }
 292         };
 293
 294         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 295         assertEquals("123-uuid", ht.getAsdcUuid());
 296     }
 297
 298     @Test(expected = HibernateException.class)
 299     public void getHeatTemplateByArtifactUuidHibernateErrorTest(){
 300
 301         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 302
 303             @Mock
 304             public Object uniqueResult() {
 305                 throw new HibernateException("hibernate exception");
 306             }
 307         };
 308
 309         MockUp<Session> mockedSession = new MockUp<Session>() {
 310             @Mock
 311             public Query createQuery(String hql) {
 312                 return mockUpQuery.getMockInstance();
 313             }
 314         };
 315
 316         new MockUp<CatalogDatabase>() {
 317             @Mock
 318             private Session getSession() {
 319                 return mockedSession.getMockInstance();
 320             }
 321         };
 322
 323         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 324     }
 325
 326     @Test(expected = NonUniqueResultException.class)
 327     public void getHeatTemplateByArtifactUuidNonUniqueResultTest(){
 328
 329         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 330
 331             @Mock
 332             public Object uniqueResult() {
 333                 throw new NonUniqueResultException(2);
 334             }
 335         };
 336
 337         MockUp<Session> mockedSession = new MockUp<Session>() {
 338             @Mock
 339             public Query createQuery(String hql) {
 340                 return mockUpQuery.getMockInstance();
 341             }
 342         };
 343
 344         new MockUp<CatalogDatabase>() {
 345             @Mock
 346             private Session getSession() {
 347                 return mockedSession.getMockInstance();
 348             }
 349         };
 350
 351         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 352     }
 353
 354     @Test(expected = Exception.class)
 355     public void getHeatTemplateByArtifactUuidGenericExceptionTest(){
 356
 357         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 358
 359             @Mock
 360             public Object uniqueResult() throws Exception {
 361                 throw new Exception();
 362             }
 363         };
 364
 365         MockUp<Session> mockedSession = new MockUp<Session>() {
 366             @Mock
 367             public Query createQuery(String hql) {
 368                 return mockUpQuery.getMockInstance();
 369             }
 370         };
 371
 372         new MockUp<CatalogDatabase>() {
 373             @Mock
 374             private Session getSession() {
 375                 return mockedSession.getMockInstance();
 376             }
 377         };
 378
 379         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 380     }
 381
 382     @Test
 383     public void getParametersForHeatTemplateTest(){
 384
 385         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 386             @Mock
 387             public List<HeatTemplate> list() {
 388                 HeatTemplate heatTemplate = new HeatTemplate();
 389                 heatTemplate.setAsdcUuid("1234-uuid");
 390                 return Arrays.asList(heatTemplate);
 391             }
 392         };
 393
 394         MockUp<Session> mockedSession = new MockUp<Session>() {
 395             @Mock
 396             public Query createQuery(String hql) {
 397                 return mockUpQuery.getMockInstance();
 398             }
 399         };
 400
 401         new MockUp<CatalogDatabase>() {
 402             @Mock
 403             private Session getSession() {
 404                 return mockedSession.getMockInstance();
 405             }
 406         };
 407
 408         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 409         assertEquals(1, htList.size());
 410     }
 411
 412     @Test(expected = HibernateException.class)
 413     public void getParametersForHeatTemplateHibernateExceptionTest(){
 414
 415         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 416             @Mock
 417             public List<HeatTemplate> list() {
 418                 throw new HibernateException("hibernate exception");
 419             }
 420         };
 421
 422         MockUp<Session> mockedSession = new MockUp<Session>() {
 423             @Mock
 424             public Query createQuery(String hql) {
 425                 return mockUpQuery.getMockInstance();
 426             }
 427         };
 428
 429         new MockUp<CatalogDatabase>() {
 430             @Mock
 431             private Session getSession() {
 432                 return mockedSession.getMockInstance();
 433             }
 434         };
 435
 436         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 437     }
 438
 439     @Test(expected = Exception.class)
 440     public void getParametersForHeatTemplateExceptionTest(){
 441
 442         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 443             @Mock
 444             public List<HeatTemplate> list() throws Exception {
 445                 throw new Exception();
 446             }
 447         };
 448
 449         MockUp<Session> mockedSession = new MockUp<Session>() {
 450             @Mock
 451             public Query createQuery(String hql) {
 452                 return mockUpQuery.getMockInstance();
 453             }
 454         };
 455
 456         new MockUp<CatalogDatabase>() {
 457             @Mock
 458             private Session getSession() {
 459                 return mockedSession.getMockInstance();
 460             }
 461         };
 462
 463         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 464     }
 465
 466     @Test
 467     public void getHeatEnvironmentByArtifactUuidTest(){
 468
 469         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 470
 471             @Mock
 472             public Object uniqueResult() {
 473                 HeatEnvironment heatEnvironment = new HeatEnvironment();
 474                 heatEnvironment.setArtifactUuid("123-uuid");
 475                 return heatEnvironment;
 476             }
 477         };
 478
 479         MockUp<Session> mockedSession = new MockUp<Session>() {
 480             @Mock
 481             public Query createQuery(String hql) {
 482                 return mockUpQuery.getMockInstance();
 483             }
 484         };
 485
 486         new MockUp<CatalogDatabase>() {
 487             @Mock
 488             private Session getSession() {
 489                 return mockedSession.getMockInstance();
 490             }
 491         };
 492
 493         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 494         assertEquals("123-uuid", he.getArtifactUuid());
 495     }
 496
 497     @Test(expected = HibernateException.class)
 498     public void getHeatEnvironmentByArtifactUuidHibernateExceptionTest(){
 499
 500         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 501
 502             @Mock
 503             public Object uniqueResult() {
 504                 throw new HibernateException("hibernate exception");
 505             }
 506         };
 507
 508         MockUp<Session> mockedSession = new MockUp<Session>() {
 509             @Mock
 510             public Query createQuery(String hql) {
 511                 return mockUpQuery.getMockInstance();
 512             }
 513         };
 514
 515         new MockUp<CatalogDatabase>() {
 516             @Mock
 517             private Session getSession() {
 518                 return mockedSession.getMockInstance();
 519             }
 520         };
 521
 522         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 523     }
 524
 525     @Test(expected = Exception.class)
 526     public void getHeatEnvironmentByArtifactUuidExceptionTest(){
 527
 528         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 529
 530             @Mock
 531             public Object uniqueResult() throws Exception {
 532                 throw new Exception();
 533             }
 534         };
 535
 536         MockUp<Session> mockedSession = new MockUp<Session>() {
 537             @Mock
 538             public Query createQuery(String hql) {
 539                 return mockUpQuery.getMockInstance();
 540             }
 541         };
 542
 543         new MockUp<CatalogDatabase>() {
 544             @Mock
 545             private Session getSession() {
 546                 return mockedSession.getMockInstance();
 547             }
 548         };
 549
 550         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 551     }
 552
 553     @Test
 554     public void getServiceByInvariantUUIDTest(){
 555
 556         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 557
 558             @Mock
 559             public List<Service> list() {
 560                 Service service = new Service();
 561                 service.setModelUUID("123-uuid");
 562                 return Arrays.asList(service);
 563             }
 564         };
 565
 566         MockUp<Session> mockedSession = new MockUp<Session>() {
 567             @Mock
 568             public Query createQuery(String hql) {
 569                 return mockUpQuery.getMockInstance();
 570             }
 571         };
 572
 573         new MockUp<CatalogDatabase>() {
 574             @Mock
 575             private Session getSession() {
 576                 return mockedSession.getMockInstance();
 577             }
 578         };
 579
 580         Service service = cd.getServiceByInvariantUUID("123");
 581         assertEquals("123-uuid", service.getModelUUID());
 582     }
 583
 584     @Test
 585     public void getServiceByInvariantUUIDEmptyResultTest(){
 586
 587         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 588
 589             @Mock
 590             public List<Service> list() {
 591                 return Arrays.asList();
 592             }
 593         };
 594
 595         MockUp<Session> mockedSession = new MockUp<Session>() {
 596             @Mock
 597             public Query createQuery(String hql) {
 598                 return mockUpQuery.getMockInstance();
 599             }
 600         };
 601
 602         new MockUp<CatalogDatabase>() {
 603             @Mock
 604             private Session getSession() {
 605                 return mockedSession.getMockInstance();
 606             }
 607         };
 608
 609         Service service = cd.getServiceByInvariantUUID("123");
 610         assertEquals(null, service);
 611     }
 612
 613     @Test
 614     public void getServiceTest(){
 615
 616         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 617
 618             @Mock
 619             public Object uniqueResult() throws Exception {
 620                 Service service = new Service();
 621                 service.setModelUUID("123-uuid");
 622                 return service;
 623             }
 624         };
 625
 626         MockUp<Session> mockedSession = new MockUp<Session>() {
 627             @Mock
 628             public Query createQuery(String hql) {
 629                 return mockUpQuery.getMockInstance();
 630             }
 631         };
 632
 633         new MockUp<CatalogDatabase>() {
 634             @Mock
 635             private Session getSession() {
 636                 return mockedSession.getMockInstance();
 637             }
 638         };
 639
 640         Service service = cd.getService("123");
 641         assertEquals("123-uuid", service.getModelUUID());
 642     }
 643
 644     @Test(expected = NonUniqueResultException.class)
 645     public void getServiceNoUniqueResultTest(){
 646
 647         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 648
 649             @Mock
 650             public Object uniqueResult() throws Exception {
 651                 throw new NonUniqueResultException(-1);
 652             }
 653         };
 654
 655         MockUp<Session> mockedSession = new MockUp<Session>() {
 656             @Mock
 657             public Query createQuery(String hql) {
 658                 return mockUpQuery.getMockInstance();
 659             }
 660         };
 661
 662         new MockUp<CatalogDatabase>() {
 663             @Mock
 664             private Session getSession() {
 665                 return mockedSession.getMockInstance();
 666             }
 667         };
 668
 669         Service service = cd.getService("123");
 670     }
 671
 672     @Test(expected = HibernateException.class)
 673     public void getServiceHibernateExceptionTest(){
 674
 675         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 676
 677             @Mock
 678             public Object uniqueResult() throws Exception {
 679                 throw new HibernateException("hibernate exception");
 680             }
 681         };
 682
 683         MockUp<Session> mockedSession = new MockUp<Session>() {
 684             @Mock
 685             public Query createQuery(String hql) {
 686                 return mockUpQuery.getMockInstance();
 687             }
 688         };
 689
 690         new MockUp<CatalogDatabase>() {
 691             @Mock
 692             private Session getSession() {
 693                 return mockedSession.getMockInstance();
 694             }
 695         };
 696
 697         Service service = cd.getService("123");
 698     }
 699
 700     @Test(expected = Exception.class)
 701     public void getServiceExceptionTest(){
 702
 703         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 704
 705             @Mock
 706             public Object uniqueResult() throws Exception {
 707                 throw new Exception("generic exception");
 708             }
 709         };
 710
 711         MockUp<Session> mockedSession = new MockUp<Session>() {
 712             @Mock
 713             public Query createQuery(String hql) {
 714                 return mockUpQuery.getMockInstance();
 715             }
 716         };
 717
 718         new MockUp<CatalogDatabase>() {
 719             @Mock
 720             private Session getSession() {
 721                 return mockedSession.getMockInstance();
 722             }
 723         };
 724
 725         Service service = cd.getService("123");
 726     }
 727
 728     @Test
 729     public void getServiceByModelUUIDTest(){
 730
 731         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 732
 733             @Mock
 734             public Object uniqueResult() throws Exception {
 735                 Service service = new Service();
 736                 service.setModelUUID("123-uuid");
 737                 return service;
 738             }
 739         };
 740
 741         MockUp<Session> mockedSession = new MockUp<Session>() {
 742             @Mock
 743             public Query createQuery(String hql) {
 744                 return mockUpQuery.getMockInstance();
 745             }
 746         };
 747
 748         new MockUp<CatalogDatabase>() {
 749             @Mock
 750             private Session getSession() {
 751                 return mockedSession.getMockInstance();
 752             }
 753         };
 754         Service service = cd.getServiceByModelUUID("123");
 755         assertEquals("123-uuid", service.getModelUUID());
 756     }
 757
 758     @Test
 759     public void getService2Test(){
 760         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 761
 762             @Mock
 763             public Object uniqueResult() throws Exception {
 764                 Service service = new Service();
 765                 service.setModelUUID("123-uuid");
 766                 return service;
 767             }
 768         };
 769
 770         MockUp<Session> mockedSession = new MockUp<Session>() {
 771             @Mock
 772             public Query createQuery(String hql) {
 773                 return mockUpQuery.getMockInstance();
 774             }
 775         };
 776
 777         new MockUp<CatalogDatabase>() {
 778             @Mock
 779             private Session getSession() {
 780                 return mockedSession.getMockInstance();
 781             }
 782         };
 783
 784         HashMap<String, String> map = new HashMap<>();
 785         map.put("serviceNameVersionId", "v2");
 786         Service service = cd.getService(map, "123");
 787
 788         assertEquals("123-uuid", service.getModelUUID());
 789     }
 790
 791     @Test
 792     public void getServiceByModelNameTest(){
 793
 794         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 795             @Mock
 796             public List<Service> list() throws Exception {
 797                 Service service = new Service();
 798                 service.setModelUUID("123-uuid");
 799                 return Arrays.asList(service);
 800             }
 801         };
 802
 803         MockUp<Session> mockedSession = new MockUp<Session>() {
 804             @Mock
 805             public Query createQuery(String hql) {
 806                 return mockUpQuery.getMockInstance();
 807             }
 808         };
 809
 810         new MockUp<CatalogDatabase>() {
 811             @Mock
 812             private Session getSession() {
 813                 return mockedSession.getMockInstance();
 814             }
 815         };
 816
 817         Service service = cd.getServiceByModelName("123");
 818         assertEquals("123-uuid", service.getModelUUID());
 819     }
 820
 821     @Test
 822     public void getServiceByModelNameEmptyTest(){
 823
 824         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 825             @Mock
 826             public List<Service> list() throws Exception {
 827                 return Arrays.asList();
 828             }
 829         };
 830
 831         MockUp<Session> mockedSession = new MockUp<Session>() {
 832             @Mock
 833             public Query createQuery(String hql) {
 834                 return mockUpQuery.getMockInstance();
 835             }
 836         };
 837
 838         new MockUp<CatalogDatabase>() {
 839             @Mock
 840             private Session getSession() {
 841                 return mockedSession.getMockInstance();
 842             }
 843         };
 844
 845         Service service = cd.getServiceByModelName("123");
 846         assertEquals(null, service);
 847     }
 848
 849     @Test
 850     public void getServiceByVersionAndInvariantIdTest() throws Exception{
 851
 852         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 853
 854             @Mock
 855             public Object uniqueResult() throws Exception {
 856                 Service service = new Service();
 857                 service.setModelUUID("123-uuid");
 858                 return service;
 859             }
 860         };
 861
 862         MockUp<Session> mockedSession = new MockUp<Session>() {
 863             @Mock
 864             public Query createQuery(String hql) {
 865                 return mockUpQuery.getMockInstance();
 866             }
 867         };
 868
 869         new MockUp<CatalogDatabase>() {
 870             @Mock
 871             private Session getSession() {
 872                 return mockedSession.getMockInstance();
 873             }
 874         };
 875         Service service = cd.getServiceByVersionAndInvariantId("123","tetwe");
 876         assertEquals("123-uuid", service.getModelUUID());
 877     }
 878
 879     @Test(expected = Exception.class)
 880     public void getServiceByVersionAndInvariantIdNonUniqueResultTest() throws Exception{
 881
 882         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 883
 884             @Mock
 885             public Object uniqueResult() throws Exception {
 886                 throw new NonUniqueResultException(-1);
 887             }
 888         };
 889
 890         MockUp<Session> mockedSession = new MockUp<Session>() {
 891             @Mock
 892             public Query createQuery(String hql) {
 893                 return mockUpQuery.getMockInstance();
 894             }
 895         };
 896
 897         new MockUp<CatalogDatabase>() {
 898             @Mock
 899             private Session getSession() {
 900                 return mockedSession.getMockInstance();
 901             }
 902         };
 903         Service service = cd.getServiceByVersionAndInvariantId("123","tetwe");
 904     }
 905
 906     @Test(expected = Exception.class)
 907     public void getServiceRecipeTestException() throws Exception{
 908         ServiceRecipe ht = cd.getServiceRecipe("123","tetwe");
 909     }
 910
 911     @Test
 912     public void getServiceRecipeByServiceModelUuidTest() {
 913         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 914             @Mock
 915             public List<ServiceRecipe> list() throws Exception {
 916                 ServiceRecipe serviceRecipe = new ServiceRecipe();
 917                 serviceRecipe.setId(1);
 918                 return Arrays.asList(serviceRecipe);
 919             }
 920         };
 921
 922         MockUp<Session> mockedSession = new MockUp<Session>() {
 923             @Mock
 924             public Query createQuery(String hql) {
 925                 return mockUpQuery.getMockInstance();
 926             }
 927         };
 928
 929         new MockUp<CatalogDatabase>() {
 930             @Mock
 931             private Session getSession() {
 932                 return mockedSession.getMockInstance();
 933             }
 934         };
 935         ServiceRecipe serviceRecipe = cd.getServiceRecipeByServiceModelUuid("123","tetwe");
 936         assertEquals(1, serviceRecipe.getId());
 937     }
 938
 939     @Test
 940     public void getServiceRecipeByServiceModelUuidEmptyTest() {
 941         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 942             @Mock
 943             public List<ServiceRecipe> list() throws Exception {
 944                 return Arrays.asList();
 945             }
 946         };
 947
 948         MockUp<Session> mockedSession = new MockUp<Session>() {
 949             @Mock
 950             public Query createQuery(String hql) {
 951                 return mockUpQuery.getMockInstance();
 952             }
 953         };
 954
 955         new MockUp<CatalogDatabase>() {
 956             @Mock
 957             private Session getSession() {
 958                 return mockedSession.getMockInstance();
 959             }
 960         };
 961         ServiceRecipe serviceRecipe = cd.getServiceRecipeByServiceModelUuid("123","tetwe");
 962         assertEquals(null, serviceRecipe);
 963     }
 964
 965     @Test
 966     public void getServiceRecipesTestException() throws Exception{
 967         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 968             @Mock
 969             public List<ServiceRecipe> list() {
 970                 ServiceRecipe serviceRecipe = new ServiceRecipe();
 971                 serviceRecipe.setId(1);
 972                 return Arrays.asList(serviceRecipe);
 973             }
 974         };
 975
 976         MockUp<Session> mockedSession = new MockUp<Session>() {
 977             @Mock
 978             public Query createQuery(String hql) {
 979                 return mockUpQuery.getMockInstance();
 980             }
 981         };
 982
 983         new MockUp<CatalogDatabase>() {
 984             @Mock
 985             private Session getSession() {
 986                 return mockedSession.getMockInstance();
 987             }
 988         };
 989         List<ServiceRecipe> serviceRecipes = cd.getServiceRecipes("123");
 990         assertEquals(1, serviceRecipes.size());
 991     }
 992
 993     @Test
 994     public void getServiceRecipesEmptyTest() throws Exception{
 995         MockUp<Query> mockUpQuery = new MockUp<Query>() {
 996             @Mock
 997             public List<ServiceRecipe> list() {
 998                 return Arrays.asList();
 999             }
1000         };
1001
1002         MockUp<Session> mockedSession = new MockUp<Session>() {
1003             @Mock
1004             public Query createQuery(String hql) {
1005                 return mockUpQuery.getMockInstance();
1006             }
1007         };
1008
1009         new MockUp<CatalogDatabase>() {
1010             @Mock
1011             private Session getSession() {
1012                 return mockedSession.getMockInstance();
1013             }
1014         };
1015         List<ServiceRecipe> serviceRecipes = cd.getServiceRecipes("123");
1016         assertEquals(0, serviceRecipes.size());
1017     }
1018
1019     @Test(expected = Exception.class)
1020     public void getVnfComponentTestException() throws Exception{
1021         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1022     }
1023
1024     @Test
1025     public void getVnfResourceTest() throws Exception{
1026         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1027             @Mock
1028             public List<VnfResource> list() {
1029                 VnfResource vnfResource = new VnfResource();
1030                 vnfResource.setModelUuid("123-uuid");
1031                 return Arrays.asList(vnfResource);
1032             }
1033         };
1034
1035         MockUp<Session> mockedSession = new MockUp<Session>() {
1036             @Mock
1037             public Query createQuery(String hql) {
1038                 return mockUpQuery.getMockInstance();
1039             }
1040         };
1041
1042         new MockUp<CatalogDatabase>() {
1043             @Mock
1044             private Session getSession() {
1045                 return mockedSession.getMockInstance();
1046             }
1047         };
1048         VnfResource vnfResource = cd.getVnfResource("vnf");
1049         assertEquals("123-uuid", vnfResource.getModelUuid());
1050     }
1051
1052     @Test
1053     public void getVnfResourceEmptyTest() throws Exception{
1054         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1055             @Mock
1056             public List<VnfResource> list() {
1057                 return Arrays.asList();
1058             }
1059         };
1060
1061         MockUp<Session> mockedSession = new MockUp<Session>() {
1062             @Mock
1063             public Query createQuery(String hql) {
1064                 return mockUpQuery.getMockInstance();
1065             }
1066         };
1067
1068         new MockUp<CatalogDatabase>() {
1069             @Mock
1070             private Session getSession() {
1071                 return mockedSession.getMockInstance();
1072             }
1073         };
1074         VnfResource vnfResource = cd.getVnfResource("vnf");
1075         assertEquals(null, vnfResource);
1076     }
1077
1078     @Test
1079     public void getVnfResourceByTypeTest() {
1080         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1081
1082             @Mock
1083             public Object uniqueResult() {
1084                 VnfResource vnfResource = new VnfResource();
1085                 vnfResource.setModelUuid("123-uuid");
1086                 return vnfResource;
1087             }
1088         };
1089
1090         MockUp<Session> mockedSession = new MockUp<Session>() {
1091             @Mock
1092             public Query createQuery(String hql) {
1093                 return mockUpQuery.getMockInstance();
1094             }
1095         };
1096
1097         new MockUp<CatalogDatabase>() {
1098             @Mock
1099             private Session getSession() {
1100                 return mockedSession.getMockInstance();
1101             }
1102         };
1103         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1104         assertEquals("123-uuid", vnfResource.getModelUuid());
1105     }
1106
1107     @Test(expected = NonUniqueResultException.class)
1108     public void getVnfResourceNURExceptionTest() {
1109         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1110
1111             @Mock
1112             public Object uniqueResult() {
1113                 throw new NonUniqueResultException(-1);
1114             }
1115         };
1116
1117         MockUp<Session> mockedSession = new MockUp<Session>() {
1118             @Mock
1119             public Query createQuery(String hql) {
1120                 return mockUpQuery.getMockInstance();
1121             }
1122         };
1123
1124         new MockUp<CatalogDatabase>() {
1125             @Mock
1126             private Session getSession() {
1127                 return mockedSession.getMockInstance();
1128             }
1129         };
1130         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1131     }
1132
1133     @Test(expected = HibernateException.class)
1134     public void getVnfResourceHibernateExceptionTest() {
1135         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1136
1137             @Mock
1138             public Object uniqueResult() {
1139                 throw new HibernateException("hibernate exception");
1140             }
1141         };
1142
1143         MockUp<Session> mockedSession = new MockUp<Session>() {
1144             @Mock
1145             public Query createQuery(String hql) {
1146                 return mockUpQuery.getMockInstance();
1147             }
1148         };
1149
1150         new MockUp<CatalogDatabase>() {
1151             @Mock
1152             private Session getSession() {
1153                 return mockedSession.getMockInstance();
1154             }
1155         };
1156         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1157     }
1158
1159     @Test(expected = Exception.class)
1160     public void getVnfResourceExceptionTest() {
1161         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1162
1163             @Mock
1164             public Object uniqueResult() throws Exception {
1165                 throw new Exception();
1166             }
1167         };
1168
1169         MockUp<Session> mockedSession = new MockUp<Session>() {
1170             @Mock
1171             public Query createQuery(String hql) {
1172                 return mockUpQuery.getMockInstance();
1173             }
1174         };
1175
1176         new MockUp<CatalogDatabase>() {
1177             @Mock
1178             private Session getSession() {
1179                 return mockedSession.getMockInstance();
1180             }
1181         };
1182         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1183     }
1184
1185     @Test
1186     public void getVnfResourceByModelCustomizationIdTest() {
1187         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1188
1189             @Mock
1190             public Object uniqueResult() throws Exception {
1191                 VnfResource vnfResource = new VnfResource();
1192                 vnfResource.setModelUuid("123-uuid");
1193                 return vnfResource;
1194             }
1195         };
1196
1197         MockUp<Session> mockedSession = new MockUp<Session>() {
1198             @Mock
1199             public Query createQuery(String hql) {
1200                 return mockUpQuery.getMockInstance();
1201             }
1202         };
1203
1204         new MockUp<CatalogDatabase>() {
1205             @Mock
1206             private Session getSession() {
1207                 return mockedSession.getMockInstance();
1208             }
1209         };
1210
1211         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1212         assertEquals("123-uuid",vnfResource.getModelUuid());
1213     }
1214
1215     @Test(expected = NonUniqueResultException.class)
1216     public void getVnfResourceByModelCustomizationIdNURExceptionTest() {
1217         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1218
1219             @Mock
1220             public Object uniqueResult() throws Exception {
1221                 throw new NonUniqueResultException(-1);
1222             }
1223         };
1224
1225         MockUp<Session> mockedSession = new MockUp<Session>() {
1226             @Mock
1227             public Query createQuery(String hql) {
1228                 return mockUpQuery.getMockInstance();
1229             }
1230         };
1231
1232         new MockUp<CatalogDatabase>() {
1233             @Mock
1234             private Session getSession() {
1235                 return mockedSession.getMockInstance();
1236             }
1237         };
1238
1239         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1240     }
1241
1242     @Test(expected = HibernateException.class)
1243     public void getVnfResourceByModelCustomizationIdHibernateExceptionTest() {
1244         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1245
1246             @Mock
1247             public Object uniqueResult() throws Exception {
1248                 throw new HibernateException("hibernate exception");
1249             }
1250         };
1251
1252         MockUp<Session> mockedSession = new MockUp<Session>() {
1253             @Mock
1254             public Query createQuery(String hql) {
1255                 return mockUpQuery.getMockInstance();
1256             }
1257         };
1258
1259         new MockUp<CatalogDatabase>() {
1260             @Mock
1261             private Session getSession() {
1262                 return mockedSession.getMockInstance();
1263             }
1264         };
1265
1266         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1267     }
1268
1269
1270     @Test(expected = Exception.class)
1271     public void getServiceRecipeTest2Exception() throws Exception{
1272         ServiceRecipe ht = cd.getServiceRecipe(1001,"3992");
1273     }
1274
1275     @Test
1276     public void getVnfResourceCustomizationByModelCustomizationNameTest(){
1277         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1278             @Mock
1279             public List<VnfResourceCustomization> list() throws Exception {
1280                 VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
1281                 vnfResourceCustomization.setVnfResourceModelUUID("123-uuid");
1282                 return Arrays.asList(vnfResourceCustomization);
1283             }
1284         };
1285
1286         MockUp<Session> mockedSession = new MockUp<Session>() {
1287             @Mock
1288             public Query createQuery(String hql) {
1289                 return mockUpQuery.getMockInstance();
1290             }
1291         };
1292
1293         new MockUp<CatalogDatabase>() {
1294             @Mock
1295             private Session getSession() {
1296                 return mockedSession.getMockInstance();
1297             }
1298         };
1299         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelCustomizationName("test", "test234");
1300         assertEquals("123-uuid", vnf.getVnfResourceModelUUID());
1301     }
1302
1303     @Test
1304     public void getVnfResourceCustomizationByModelCustomizationNameEmptyTest(){
1305         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1306             @Mock
1307             public List<VnfResourceCustomization> list() throws Exception {
1308                 return Arrays.asList();
1309             }
1310         };
1311
1312         MockUp<Session> mockedSession = new MockUp<Session>() {
1313             @Mock
1314             public Query createQuery(String hql) {
1315                 return mockUpQuery.getMockInstance();
1316             }
1317         };
1318
1319         new MockUp<CatalogDatabase>() {
1320             @Mock
1321             private Session getSession() {
1322                 return mockedSession.getMockInstance();
1323             }
1324         };
1325         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelCustomizationName("test", "test234");
1326         assertEquals(null, vnf);
1327     }
1328
1329     @Test
1330     public void getVnfResourceByModelInvariantIdTest(){
1331         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1332
1333             @Mock
1334             public Object uniqueResult(){
1335                 VnfResource vnfResource = new VnfResource();
1336                 vnfResource.setModelUuid("123-uuid");
1337                 return vnfResource;
1338             }
1339         };
1340
1341         MockUp<Session> mockedSession = new MockUp<Session>() {
1342             @Mock
1343             public Query createQuery(String hql) {
1344                 return mockUpQuery.getMockInstance();
1345             }
1346         };
1347
1348         new MockUp<CatalogDatabase>() {
1349             @Mock
1350             private Session getSession() {
1351                 return mockedSession.getMockInstance();
1352             }
1353         };
1354         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1355         assertEquals("123-uuid", vnf.getModelUuid());
1356     }
1357
1358     @Test(expected = NonUniqueResultException.class)
1359     public void getVnfResourceByModelInvariantIdNURExceptionTest(){
1360         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1361
1362             @Mock
1363             public Object uniqueResult(){
1364                 throw new NonUniqueResultException(-1);
1365             }
1366         };
1367
1368         MockUp<Session> mockedSession = new MockUp<Session>() {
1369             @Mock
1370             public Query createQuery(String hql) {
1371                 return mockUpQuery.getMockInstance();
1372             }
1373         };
1374
1375         new MockUp<CatalogDatabase>() {
1376             @Mock
1377             private Session getSession() {
1378                 return mockedSession.getMockInstance();
1379             }
1380         };
1381         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1382     }
1383
1384     @Test(expected = HibernateException.class)
1385     public void getVnfResourceByModelInvariantIdHibernateExceptionTest(){
1386         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1387
1388             @Mock
1389             public Object uniqueResult(){
1390                 throw new HibernateException("hibernate exception");
1391             }
1392         };
1393
1394         MockUp<Session> mockedSession = new MockUp<Session>() {
1395             @Mock
1396             public Query createQuery(String hql) {
1397                 return mockUpQuery.getMockInstance();
1398             }
1399         };
1400
1401         new MockUp<CatalogDatabase>() {
1402             @Mock
1403             private Session getSession() {
1404                 return mockedSession.getMockInstance();
1405             }
1406         };
1407         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1408     }
1409
1410     @Test(expected = Exception.class)
1411     public void getVnfResourceByModelInvariantIdExceptionTest(){
1412         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1413
1414             @Mock
1415             public Object uniqueResult() throws Exception {
1416                 throw new Exception();
1417             }
1418         };
1419
1420         MockUp<Session> mockedSession = new MockUp<Session>() {
1421             @Mock
1422             public Query createQuery(String hql) {
1423                 return mockUpQuery.getMockInstance();
1424             }
1425         };
1426
1427         new MockUp<CatalogDatabase>() {
1428             @Mock
1429             private Session getSession() {
1430                 return mockedSession.getMockInstance();
1431             }
1432         };
1433         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1434     }
1435
1436     @Test(expected = Exception.class)
1437     public void getVnfResourceByIdTestException(){
1438         VnfResource vnf = cd.getVnfResourceById(19299);
1439     }
1440
1441     @Test
1442     public void getVfModuleModelName(){
1443         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1444             @Mock
1445             public List<VfModule> list() throws Exception {
1446                 VfModule vfModule = new VfModule();
1447                 vfModule.setModelUUID("123-uuid");
1448                 return Arrays.asList(vfModule);
1449             }
1450         };
1451
1452         MockUp<Session> mockedSession = new MockUp<Session>() {
1453             @Mock
1454             public Query createQuery(String hql) {
1455                 return mockUpQuery.getMockInstance();
1456             }
1457         };
1458
1459         new MockUp<CatalogDatabase>() {
1460             @Mock
1461             private Session getSession() {
1462                 return mockedSession.getMockInstance();
1463             }
1464         };
1465         VfModule vfModule = cd.getVfModuleModelName("vfmodule");
1466         assertEquals("123-uuid", vfModule.getModelUUID());
1467     }
1468
1469     @Test
1470     public void getVfModuleModelNameExceptionTest(){
1471         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1472             @Mock
1473             public List<VfModule> list() throws Exception {
1474                 return Arrays.asList();
1475             }
1476         };
1477
1478         MockUp<Session> mockedSession = new MockUp<Session>() {
1479             @Mock
1480             public Query createQuery(String hql) {
1481                 return mockUpQuery.getMockInstance();
1482             }
1483         };
1484
1485         new MockUp<CatalogDatabase>() {
1486             @Mock
1487             private Session getSession() {
1488                 return mockedSession.getMockInstance();
1489             }
1490         };
1491         VfModule vfModule = cd.getVfModuleModelName("vfmodule");
1492         assertEquals(null, vfModule);
1493     }
1494
1495     @Test
1496     public void getVfModuleModelNameTest() {
1497         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1498
1499             @Mock
1500             public Object uniqueResult() {
1501                 VfModule vfModule = new VfModule();
1502                 vfModule.setModelUUID("123-uuid");
1503                 return vfModule;
1504             }
1505         };
1506
1507         MockUp<Session> mockedSession = new MockUp<Session>() {
1508             @Mock
1509             public Query createQuery(String hql) {
1510                 return mockUpQuery.getMockInstance();
1511             }
1512         };
1513
1514         new MockUp<CatalogDatabase>() {
1515             @Mock
1516             private Session getSession() {
1517                 return mockedSession.getMockInstance();
1518             }
1519         };
1520
1521         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
1522         assertEquals("123-uuid", vfModule.getModelUUID());
1523     }
1524
1525     @Test(expected = NonUniqueResultException.class)
1526     public void getVfModuleModelNameNURExceptionTest() {
1527         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1528
1529             @Mock
1530             public Object uniqueResult() {
1531                 throw new NonUniqueResultException(-1);
1532             }
1533         };
1534
1535         MockUp<Session> mockedSession = new MockUp<Session>() {
1536             @Mock
1537             public Query createQuery(String hql) {
1538                 return mockUpQuery.getMockInstance();
1539             }
1540         };
1541
1542         new MockUp<CatalogDatabase>() {
1543             @Mock
1544             private Session getSession() {
1545                 return mockedSession.getMockInstance();
1546             }
1547         };
1548
1549         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
1550     }
1551
1552     @Test(expected = HibernateException.class)
1553     public void getVfModuleModelNameHibernateExceptionTest() {
1554         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1555
1556             @Mock
1557             public Object uniqueResult() {
1558                 throw new HibernateException("hibernate exception");
1559             }
1560         };
1561
1562         MockUp<Session> mockedSession = new MockUp<Session>() {
1563             @Mock
1564             public Query createQuery(String hql) {
1565                 return mockUpQuery.getMockInstance();
1566             }
1567         };
1568
1569         new MockUp<CatalogDatabase>() {
1570             @Mock
1571             private Session getSession() {
1572                 return mockedSession.getMockInstance();
1573             }
1574         };
1575
1576         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
1577     }
1578
1579     @Test(expected = Exception.class)
1580     public void getVfModuleModelNameGenericExceptionTest() {
1581         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1582
1583             @Mock
1584             public Object uniqueResult() throws Exception {
1585                 throw new Exception();
1586             }
1587         };
1588
1589         MockUp<Session> mockedSession = new MockUp<Session>() {
1590             @Mock
1591             public Query createQuery(String hql) {
1592                 return mockUpQuery.getMockInstance();
1593             }
1594         };
1595
1596         new MockUp<CatalogDatabase>() {
1597             @Mock
1598             private Session getSession() {
1599                 return mockedSession.getMockInstance();
1600             }
1601         };
1602
1603         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
1604     }
1605
1606     @Test
1607     public void ggetVfModuleCustomizationByModelNameTest(){
1608         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1609             @Mock
1610             public List<VfModuleCustomization> list() throws Exception {
1611                 VfModuleCustomization vfModuleCustomization = new VfModuleCustomization();
1612                 vfModuleCustomization.setVfModuleModelUuid("123-uuid");
1613                 return Arrays.asList(vfModuleCustomization);
1614             }
1615         };
1616
1617         MockUp<Session> mockedSession = new MockUp<Session>() {
1618             @Mock
1619             public Query createQuery(String hql) {
1620                 return mockUpQuery.getMockInstance();
1621             }
1622         };
1623
1624         new MockUp<CatalogDatabase>() {
1625             @Mock
1626             private Session getSession() {
1627                 return mockedSession.getMockInstance();
1628             }
1629         };
1630         VfModuleCustomization vfModuleCustomization = cd.getVfModuleCustomizationByModelName("tetes");
1631         assertEquals("123-uuid", vfModuleCustomization.getVfModuleModelUuid());
1632     }
1633
1634     @Test
1635     public void ggetVfModuleCustomizationByModelNameEmptyTest(){
1636         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1637             @Mock
1638             public List<VfModuleCustomization> list() throws Exception {
1639                 return Arrays.asList();
1640             }
1641         };
1642
1643         MockUp<Session> mockedSession = new MockUp<Session>() {
1644             @Mock
1645             public Query createQuery(String hql) {
1646                 return mockUpQuery.getMockInstance();
1647             }
1648         };
1649
1650         new MockUp<CatalogDatabase>() {
1651             @Mock
1652             private Session getSession() {
1653                 return mockedSession.getMockInstance();
1654             }
1655         };
1656         VfModuleCustomization vfModuleCustomization = cd.getVfModuleCustomizationByModelName("tetes");
1657         assertEquals(null, vfModuleCustomization);
1658     }
1659
1660     @Test
1661     public void getNetworkResourceTest(){
1662         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1663             @Mock
1664             public List<NetworkResource> list() throws Exception {
1665                 NetworkResource networkResource = new NetworkResource();
1666                 networkResource.setModelUUID("123-uuid");
1667                 return Arrays.asList(networkResource);
1668             }
1669         };
1670
1671         MockUp<Session> mockedSession = new MockUp<Session>() {
1672             @Mock
1673             public Query createQuery(String hql) {
1674                 return mockUpQuery.getMockInstance();
1675             }
1676         };
1677
1678         new MockUp<CatalogDatabase>() {
1679             @Mock
1680             private Session getSession() {
1681                 return mockedSession.getMockInstance();
1682             }
1683         };
1684         NetworkResource networkResource = cd.getNetworkResource("tetes");
1685         assertEquals("123-uuid", networkResource.getModelUUID());
1686     }
1687
1688     @Test
1689     public void getNetworkResourceTestEmptyException(){
1690         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1691             @Mock
1692             public List<NetworkResource> list() throws Exception {
1693                 return Arrays.asList();
1694             }
1695         };
1696
1697         MockUp<Session> mockedSession = new MockUp<Session>() {
1698             @Mock
1699             public Query createQuery(String hql) {
1700                 return mockUpQuery.getMockInstance();
1701             }
1702         };
1703
1704         new MockUp<CatalogDatabase>() {
1705             @Mock
1706             private Session getSession() {
1707                 return mockedSession.getMockInstance();
1708             }
1709         };
1710         NetworkResource networkResource = cd.getNetworkResource("tetes");
1711         assertEquals(null, networkResource);
1712     }
1713
1714     @Test
1715     public void getVnfRecipeTest(){
1716
1717         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1718             @Mock
1719             public List<VnfRecipe> list() throws Exception {
1720                 VnfRecipe vnfRecipe = new VnfRecipe();
1721                 vnfRecipe.setVfModuleId("123-id");
1722                 return Arrays.asList(vnfRecipe);
1723             }
1724         };
1725
1726         MockUp<Session> mockedSession = new MockUp<Session>() {
1727             @Mock
1728             public Query createQuery(String hql) {
1729                 return mockUpQuery.getMockInstance();
1730             }
1731         };
1732
1733         new MockUp<CatalogDatabase>() {
1734             @Mock
1735             private Session getSession() {
1736                 return mockedSession.getMockInstance();
1737             }
1738         };
1739
1740         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","ergfedrf","4993493");
1741         assertEquals("123-id", vnfRecipe.getVfModuleId());
1742     }
1743
1744     @Test
1745     public void getVnfRecipeEmptyTest(){
1746
1747         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1748             @Mock
1749             public List<VnfRecipe> list() throws Exception {
1750                 return Collections.emptyList();
1751             }
1752         };
1753
1754         MockUp<Session> mockedSession = new MockUp<Session>() {
1755             @Mock
1756             public Query createQuery(String hql) {
1757                 return mockUpQuery.getMockInstance();
1758             }
1759         };
1760
1761         new MockUp<CatalogDatabase>() {
1762             @Mock
1763             private Session getSession() {
1764                 return mockedSession.getMockInstance();
1765             }
1766         };
1767
1768         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","ergfedrf","4993493");
1769         assertEquals(null, vnfRecipe);
1770     }
1771
1772     @Test
1773     public void getVnfRecipe2Test(){
1774         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1775             @Mock
1776             public List<VnfRecipe> list() throws Exception {
1777                 VnfRecipe vnfRecipe = new VnfRecipe();
1778                 vnfRecipe.setId(1);
1779                 return Arrays.asList(vnfRecipe);
1780             }
1781         };
1782
1783         MockUp<Session> mockedSession = new MockUp<Session>() {
1784             @Mock
1785             public Query createQuery(String hql) {
1786                 return mockUpQuery.getMockInstance();
1787             }
1788         };
1789
1790         new MockUp<CatalogDatabase>() {
1791             @Mock
1792             private Session getSession() {
1793                 return mockedSession.getMockInstance();
1794             }
1795         };
1796         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","4993493");
1797         assertEquals(1, vnfRecipe.getId());
1798     }
1799
1800     @Test
1801     public void getVnfRecipe2EmptyTest(){
1802         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1803             @Mock
1804             public List<VnfRecipe> list() throws Exception {
1805                 return Collections.emptyList();
1806             }
1807         };
1808
1809         MockUp<Session> mockedSession = new MockUp<Session>() {
1810             @Mock
1811             public Query createQuery(String hql) {
1812                 return mockUpQuery.getMockInstance();
1813             }
1814         };
1815
1816         new MockUp<CatalogDatabase>() {
1817             @Mock
1818             private Session getSession() {
1819                 return mockedSession.getMockInstance();
1820             }
1821         };
1822         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","4993493");
1823         assertEquals(null, vnfRecipe);
1824     }
1825
1826     @Test
1827     public void getVnfRecipeByVfModuleIdTest(){
1828         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1829             @Mock
1830             public List<VnfRecipe> list() throws Exception {
1831                 VnfRecipe vnfRecipe = new VnfRecipe();
1832                 vnfRecipe.setId(1);
1833                 return Arrays.asList(vnfRecipe);
1834             }
1835         };
1836
1837         MockUp<Session> mockedSession = new MockUp<Session>() {
1838             @Mock
1839             public Query createQuery(String hql) {
1840                 return mockUpQuery.getMockInstance();
1841             }
1842         };
1843
1844         new MockUp<CatalogDatabase>() {
1845             @Mock
1846             private Session getSession() {
1847                 return mockedSession.getMockInstance();
1848             }
1849         };
1850
1851         VnfRecipe vnfRecipe = cd.getVnfRecipeByVfModuleId("tetes","4993493","vnf");
1852         assertEquals(1, vnfRecipe.getId());
1853     }
1854
1855     @Test
1856     public void getVnfRecipeByVfModuleIdEmptyTest(){
1857         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1858             @Mock
1859             public List<VnfRecipe> list() throws Exception {
1860                 return Collections.emptyList();
1861             }
1862         };
1863
1864         MockUp<Session> mockedSession = new MockUp<Session>() {
1865             @Mock
1866             public Query createQuery(String hql) {
1867                 return mockUpQuery.getMockInstance();
1868             }
1869         };
1870
1871         new MockUp<CatalogDatabase>() {
1872             @Mock
1873             private Session getSession() {
1874                 return mockedSession.getMockInstance();
1875             }
1876         };
1877
1878         VnfRecipe vnfRecipe = cd.getVnfRecipeByVfModuleId("tetes","4993493","vnf");
1879         assertEquals(null, vnfRecipe);
1880     }
1881
1882     @Test(expected = Exception.class)
1883     public void getVfModuleTypeTestException(){
1884         VfModule vnf = cd.getVfModuleType("4993493");
1885     }
1886
1887     @Test(expected = Exception.class)
1888     public void getVfModuleType2TestException(){
1889         VfModule vnf = cd.getVfModuleType("4993493","vnf");
1890     }
1891     @Test
1892     public void getVnfResourceByServiceUuidTest(){
1893         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1894
1895             @Mock
1896             public Object uniqueResult() {
1897                 VnfResource vnfResource = new VnfResource();
1898                 vnfResource.setModelUuid("123-uuid");
1899                 return vnfResource;
1900             }
1901         };
1902
1903         MockUp<Session> mockedSession = new MockUp<Session>() {
1904             @Mock
1905             public Query createQuery(String hql) {
1906                 return mockUpQuery.getMockInstance();
1907             }
1908         };
1909
1910         new MockUp<CatalogDatabase>() {
1911             @Mock
1912             private Session getSession() {
1913                 return mockedSession.getMockInstance();
1914             }
1915         };
1916         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
1917         assertEquals("123-uuid", vnfResource.getModelUuid());
1918     }
1919
1920     @Test(expected = NonUniqueResultException.class)
1921     public void getVnfResourceByServiceUuidNURExceptionTest(){
1922         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1923
1924             @Mock
1925             public Object uniqueResult() {
1926                 throw new NonUniqueResultException(-1);
1927             }
1928         };
1929
1930         MockUp<Session> mockedSession = new MockUp<Session>() {
1931             @Mock
1932             public Query createQuery(String hql) {
1933                 return mockUpQuery.getMockInstance();
1934             }
1935         };
1936
1937         new MockUp<CatalogDatabase>() {
1938             @Mock
1939             private Session getSession() {
1940                 return mockedSession.getMockInstance();
1941             }
1942         };
1943         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
1944     }
1945
1946     @Test(expected = HibernateException.class)
1947     public void getVnfResourceByServiceUuidHibernateExceptionTest(){
1948         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1949
1950             @Mock
1951             public Object uniqueResult() {
1952                 throw new HibernateException("hibernate exception");
1953             }
1954         };
1955
1956         MockUp<Session> mockedSession = new MockUp<Session>() {
1957             @Mock
1958             public Query createQuery(String hql) {
1959                 return mockUpQuery.getMockInstance();
1960             }
1961         };
1962
1963         new MockUp<CatalogDatabase>() {
1964             @Mock
1965             private Session getSession() {
1966                 return mockedSession.getMockInstance();
1967             }
1968         };
1969         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
1970     }
1971
1972     @Test(expected = Exception.class)
1973     public void getVnfResourceByServiceUuidExceptionTest(){
1974         MockUp<Query> mockUpQuery = new MockUp<Query>() {
1975
1976             @Mock
1977             public Object uniqueResult() throws Exception {
1978                 throw new Exception();
1979             }
1980         };
1981
1982         MockUp<Session> mockedSession = new MockUp<Session>() {
1983             @Mock
1984             public Query createQuery(String hql) {
1985                 return mockUpQuery.getMockInstance();
1986             }
1987         };
1988
1989         new MockUp<CatalogDatabase>() {
1990             @Mock
1991             private Session getSession() {
1992                 return mockedSession.getMockInstance();
1993             }
1994         };
1995         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
1996     }
1997
1998     @Test
1999     public void getVnfResourceByVnfUuidTest(){
2000         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2001
2002             @Mock
2003             public Object uniqueResult() {
2004                 VnfResource vnfResource = new VnfResource();
2005                 vnfResource.setModelUuid("123-uuid");
2006                 return vnfResource;
2007             }
2008         };
2009
2010         MockUp<Session> mockedSession = new MockUp<Session>() {
2011             @Mock
2012             public Query createQuery(String hql) {
2013                 return mockUpQuery.getMockInstance();
2014             }
2015         };
2016
2017         new MockUp<CatalogDatabase>() {
2018             @Mock
2019             private Session getSession() {
2020                 return mockedSession.getMockInstance();
2021             }
2022         };
2023
2024         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2025         assertEquals("123-uuid", vnfResource.getModelUuid());
2026     }
2027
2028     @Test(expected = NonUniqueResultException.class)
2029     public void getVnfResourceByVnfUuidNURExceptionTest(){
2030         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2031
2032             @Mock
2033             public Object uniqueResult() {
2034                 throw new NonUniqueResultException(-1);
2035             }
2036         };
2037
2038         MockUp<Session> mockedSession = new MockUp<Session>() {
2039             @Mock
2040             public Query createQuery(String hql) {
2041                 return mockUpQuery.getMockInstance();
2042             }
2043         };
2044
2045         new MockUp<CatalogDatabase>() {
2046             @Mock
2047             private Session getSession() {
2048                 return mockedSession.getMockInstance();
2049             }
2050         };
2051
2052         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2053     }
2054
2055     @Test(expected = HibernateException.class)
2056     public void getVnfResourceByVnfUuidHibernateExceptionTest(){
2057         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2058
2059             @Mock
2060             public Object uniqueResult() {
2061                 throw new HibernateException("hibernate exception");
2062             }
2063         };
2064
2065         MockUp<Session> mockedSession = new MockUp<Session>() {
2066             @Mock
2067             public Query createQuery(String hql) {
2068                 return mockUpQuery.getMockInstance();
2069             }
2070         };
2071
2072         new MockUp<CatalogDatabase>() {
2073             @Mock
2074             private Session getSession() {
2075                 return mockedSession.getMockInstance();
2076             }
2077         };
2078
2079         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2080     }
2081
2082     @Test(expected = Exception.class)
2083     public void getVnfResourceByVnfUuidExceptionTest(){
2084         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2085
2086             @Mock
2087             public Object uniqueResult() throws Exception {
2088                 throw new Exception();
2089             }
2090         };
2091
2092         MockUp<Session> mockedSession = new MockUp<Session>() {
2093             @Mock
2094             public Query createQuery(String hql) {
2095                 return mockUpQuery.getMockInstance();
2096             }
2097         };
2098
2099         new MockUp<CatalogDatabase>() {
2100             @Mock
2101             private Session getSession() {
2102                 return mockedSession.getMockInstance();
2103             }
2104         };
2105
2106         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2107     }
2108
2109     @Test
2110     public void getVfModuleByModelInvariantUuidTest(){
2111
2112         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2113
2114             @Mock
2115             public List<VfModule> list() throws Exception {
2116                 VfModule vfModule = new VfModule();
2117                 vfModule.setModelUUID("123-uuid");
2118                 return Arrays.asList(vfModule);
2119             }
2120         };
2121
2122         MockUp<Session> mockedSession = new MockUp<Session>() {
2123             @Mock
2124             public Query createQuery(String hql) {
2125                 return mockUpQuery.getMockInstance();
2126             }
2127         };
2128
2129         new MockUp<CatalogDatabase>() {
2130             @Mock
2131             private Session getSession() {
2132                 return mockedSession.getMockInstance();
2133             }
2134         };
2135
2136         VfModule vfModule = cd.getVfModuleByModelInvariantUuid("4993493");
2137         assertEquals("123-uuid", vfModule.getModelUUID());
2138     }
2139
2140     @Test
2141     public void getVfModuleByModelInvariantUuidEmptyTest(){
2142
2143         MockUp<Query> mockUpQuery = new MockUp<Query>() {
2144
2145             @Mock
2146             public List<VfModule> list() throws Exception {
2147                 return Collections.emptyList();
2148             }
2149         };
2150
2151         MockUp<Session> mockedSession = new MockUp<Session>() {
2152             @Mock
2153             public Query createQuery(String hql) {
2154                 return mockUpQuery.getMockInstance();
2155             }
2156         };
2157
2158         new MockUp<CatalogDatabase>() {
2159             @Mock
2160             private Session getSession() {
2161                 return mockedSession.getMockInstance();
2162             }
2163         };
2164
2165         VfModule vfModule = cd.getVfModuleByModelInvariantUuid("4993493");
2166         assertEquals(null, vfModule);
2167     }
2168
2169     @Test(expected = Exception.class)
2170     public void getVfModuleByModelCustomizationUuidTestException(){
2171         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
2172     }
2173     @Test(expected = Exception.class)
2174     public void getVfModuleByModelInvariantUuidAndModelVersionTestException(){
2175         VfModule vnf = cd.getVfModuleByModelInvariantUuidAndModelVersion("4993493","vnf");
2176     }
2177     @Test(expected = Exception.class)
2178     public void getVfModuleCustomizationByModelCustomizationIdTestException(){
2179         VfModuleCustomization vnf = cd.getVfModuleCustomizationByModelCustomizationId("4993493");
2180     }
2181     @Test(expected = Exception.class)
2182     public void getVfModuleByModelUuidTestException(){
2183         VfModule vnf = cd.getVfModuleByModelUuid("4993493");
2184     }
2185     @Test(expected = Exception.class)
2186     public void getVnfResourceCustomizationByModelCustomizationUuidTestException(){
2187         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelCustomizationUuid("4993493");
2188     }
2189     @Test(expected = Exception.class)
2190     public void getVnfResourceCustomizationByModelVersionIdTestException(){
2191         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelVersionId("4993493");
2192     }
2193     @Test(expected = Exception.class)
2194     public void getVfModuleByModelCustomizationIdAndVersionTestException(){
2195         cd.getVfModuleByModelCustomizationIdAndVersion("4993493","test");
2196     }
2197     @Test(expected = Exception.class)
2198     public void getVfModuleByModelCustomizationIdModelVersionAndModelInvariantIdTestException(){
2199         cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("4993493","vnf","test");
2200     }
2201     @Test(expected = Exception.class)
2202     public void getVnfResourceCustomizationByModelInvariantIdTest(){
2203         cd.getVnfResourceCustomizationByModelInvariantId("4993493","vnf","test");
2204     }
2205     @Test(expected = Exception.class)
2206     public void getVfModuleCustomizationByVnfModuleCustomizationUuidTest(){
2207         cd.getVfModuleCustomizationByVnfModuleCustomizationUuid("4993493");
2208     }
2209     @Test(expected = Exception.class)
2210     public void getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionIdTest(){
2211         cd.getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId("4993493","test");
2212     }
2213     @Test(expected = Exception.class)
2214     public void getAllVfModuleCustomizationstest(){
2215         cd.getAllVfModuleCustomizations("4993493");
2216     }
2217     @Test(expected = Exception.class)
2218     public void getVnfResourceByModelUuidTest(){
2219         cd.getVnfResourceByModelUuid("4993493");
2220     }
2221     @Test(expected = Exception.class)
2222     public void getVnfResCustomToVfModuleTest(){
2223         cd.getVnfResCustomToVfModule("4993493","test");
2224     }
2225     @Test(expected = Exception.class)
2226     public void getVfModulesForVnfResourceTest(){
2227         VnfResource vnfResource = new VnfResource();
2228         vnfResource.setModelUuid("48839");
2229         cd.getVfModulesForVnfResource(vnfResource);
2230     }
2231     @Test(expected = Exception.class)
2232     public void getVfModulesForVnfResource2Test(){
2233         cd.getVfModulesForVnfResource("4993493");
2234     }
2235     @Test(expected = Exception.class)
2236     public void getServiceByUuidTest(){
2237         cd.getServiceByUuid("4993493");
2238     }
2239     @Test(expected = Exception.class)
2240     public void getNetworkResourceById2Test(){
2241         cd.getNetworkResourceById(4993493);
2242     }
2243     @Test(expected = Exception.class)
2244     public void getNetworkResourceByIdTest(){
2245         cd.getVfModuleTypeByUuid("4993493");
2246     }
2247     @Test
2248     public void isEmptyOrNullTest(){
2249         boolean is = cd.isEmptyOrNull("4993493");
2250         assertFalse(is);
2251     }
2252     @Test(expected = Exception.class)
2253     public void getSTRTest(){
2254         cd.getSTR("4993493","test","vnf");
2255     }
2256     @Test(expected = Exception.class)
2257     public void getVRCtoVFMCTest(){
2258         cd.getVRCtoVFMC("4993493","388492");
2259     }
2260     @Test(expected = Exception.class)
2261     public void getVfModuleTypeByUuidTestException(){
2262         cd.getVfModuleTypeByUuid("4993493");
2263     }
2264
2265     @Test(expected = Exception.class)
2266     public void getTempNetworkHeatTemplateLookupTest(){
2267         cd.getTempNetworkHeatTemplateLookup("4993493");
2268     }
2269
2270     @Test(expected = Exception.class)
2271     public void getAllNetworksByServiceModelUuidTest(){
2272         cd.getAllNetworksByServiceModelUuid("4993493");
2273     }
2274     @Test(expected = Exception.class)
2275     public void getAllNetworksByServiceModelInvariantUuidTest(){
2276         cd.getAllNetworksByServiceModelInvariantUuid("4993493");
2277     }
2278     @Test(expected = Exception.class)
2279     public void getAllNetworksByServiceModelInvariantUuid2Test(){
2280         cd.getAllNetworksByServiceModelInvariantUuid("4993493","test");
2281     }
2282     @Test(expected = Exception.class)
2283     public void getAllNetworksByNetworkModelCustomizationUuidTest(){
2284         cd.getAllNetworksByNetworkModelCustomizationUuid("4993493");
2285     }
2286     @Test(expected = Exception.class)
2287     public void getAllNetworksByNetworkTypeTest(){
2288         cd.getAllNetworksByNetworkType("4993493");
2289     }
2290     @Test(expected = Exception.class)
2291     public void getAllVfmcForVrcTest(){
2292         VnfResourceCustomization re = new VnfResourceCustomization();
2293         re.setModelCustomizationUuid("377483");
2294         cd.getAllVfmcForVrc(re);
2295     }
2296     @Test(expected = Exception.class)
2297     public void getAllVnfsByServiceModelUuidTest(){
2298         cd.getAllVnfsByServiceModelUuid("4993493");
2299     }
2300     @Test(expected = Exception.class)
2301     public void getAllVnfsByServiceModelInvariantUuidTest(){
2302         cd.getAllVnfsByServiceModelInvariantUuid("4993493");
2303     }
2304     @Test(expected = Exception.class)
2305     public void getAllVnfsByServiceModelInvariantUuid2Test(){
2306         cd.getAllVnfsByServiceModelInvariantUuid("4993493","test");
2307     }
2308     @Test(expected = Exception.class)
2309     public void getAllVnfsByServiceNameTest(){
2310         cd.getAllVnfsByServiceName("4993493","test");
2311     }
2312     @Test(expected = Exception.class)
2313     public void getAllVnfsByServiceName2Test(){
2314         cd.getAllVnfsByServiceName("4993493");
2315     }
2316     @Test(expected = Exception.class)
2317     public void getAllVnfsByVnfModelCustomizationUuidTest(){
2318         cd.getAllVnfsByVnfModelCustomizationUuid("4993493");
2319     }
2320     @Test(expected = Exception.class)
2321     public void getAllAllottedResourcesByServiceModelUuidTest(){
2322         cd.getAllAllottedResourcesByServiceModelUuid("4993493");
2323     }
2324     @Test(expected = Exception.class)
2325     public void getAllAllottedResourcesByServiceModelInvariantUuidTest(){
2326         cd.getAllAllottedResourcesByServiceModelInvariantUuid("4993493");
2327     }
2328     @Test(expected = Exception.class)
2329     public void getAllAllottedResourcesByServiceModelInvariantUuid2Test(){
2330         cd.getAllAllottedResourcesByServiceModelInvariantUuid("4993493","test");
2331     }
2332     @Test(expected = Exception.class)
2333     public void getAllAllottedResourcesByArModelCustomizationUuidTest(){
2334         cd.getAllAllottedResourcesByArModelCustomizationUuid("4993493");
2335     }
2336     @Test(expected = Exception.class)
2337     public void getAllottedResourceByModelUuidTest(){
2338         cd.getAllottedResourceByModelUuid("4993493");
2339     }
2340     @Test(expected = Exception.class)
2341     public void getAllResourcesByServiceModelUuidTest(){
2342         cd.getAllResourcesByServiceModelUuid("4993493");
2343     }
2344     @Test(expected = Exception.class)
2345     public void getAllResourcesByServiceModelInvariantUuidTest(){
2346         cd.getAllResourcesByServiceModelInvariantUuid("4993493");
2347     }
2348
2349     @Test(expected = Exception.class)
2350     public void getAllResourcesByServiceModelInvariantUuid2Test(){
2351         cd.getAllResourcesByServiceModelInvariantUuid("4993493","test");
2352     }
2353     @Test(expected = Exception.class)
2354     public void getSingleNetworkByModelCustomizationUuidTest(){
2355         cd.getSingleNetworkByModelCustomizationUuid("4993493");
2356     }
2357     @Test(expected = Exception.class)
2358     public void getSingleAllottedResourceByModelCustomizationUuidTest(){
2359         cd.getSingleAllottedResourceByModelCustomizationUuid("4993493");
2360     }
2361     @Test(expected = Exception.class)
2362     public void getVfModuleRecipeTest(){
2363         cd.getVfModuleRecipe("4993493","test","get");
2364     }
2365     @Test(expected = Exception.class)
2366     public void getVfModuleTest(){
2367         cd.getVfModule("4993493","test","get","v2","vnf");
2368     }
2369     @Test(expected = Exception.class)
2370     public void getVnfComponentsRecipeTest(){
2371         cd.getVnfComponentsRecipe("4993493","test","v2","vnf","get","3992");
2372     }
2373     @Test(expected = Exception.class)
2374     public void getVnfComponentsRecipeByVfModuleTest(){
2375         List <VfModule> resultList = new ArrayList<>();
2376         VfModule m = new VfModule();
2377         resultList.add(m);
2378         cd.getVnfComponentsRecipeByVfModule(resultList,"4993493");
2379     }
2380     @Test(expected = Exception.class)
2381     public void getAllVnfResourcesTest(){
2382         cd.getAllVnfResources();
2383     }
2384     @Test(expected = Exception.class)
2385     public void getVnfResourcesByRoleTest(){
2386         cd.getVnfResourcesByRole("4993493");
2387     }
2388     @Test(expected = Exception.class)
2389     public void getVnfResourceCustomizationsByRoleTest(){
2390         cd.getVnfResourceCustomizationsByRole("4993493");
2391     }
2392     @Test(expected = Exception.class)
2393     public void getAllNetworkResourcesTest(){
2394         cd.getAllNetworkResources();
2395     }
2396     @Test(expected = Exception.class)
2397     public void getAllNetworkResourceCustomizationsTest(){
2398         cd.getAllNetworkResourceCustomizations();
2399     }
2400     @Test(expected = Exception.class)
2401     public void getAllVfModulesTest(){
2402         cd.getAllVfModules();
2403     }
2404     @Test(expected = Exception.class)
2405     public void getAllVfModuleCustomizationsTest(){
2406         cd.getAllVfModuleCustomizations();
2407     }
2408     @Test(expected = Exception.class)
2409     public void getAllHeatEnvironmentTest(){
2410         cd.getAllHeatEnvironment();
2411     }
2412     @Test(expected = Exception.class)
2413     public void getHeatEnvironment2Test(){
2414         cd.getHeatEnvironment(4993493);
2415     }
2416     @Test(expected = Exception.class)
2417     public void getNestedTemplatesTest(){
2418         cd.getNestedTemplates(4993493);
2419     }
2420     @Test(expected = Exception.class)
2421     public void getNestedTemplates2Test(){
2422         cd.getNestedTemplates("4993493");
2423     }
2424     @Test(expected = Exception.class)
2425     public void getHeatFilesTest(){
2426         cd.getHeatFiles(4993493);
2427     }
2428     @Test(expected = Exception.class)
2429     public void getVfModuleToHeatFilesEntryTest(){
2430         cd.getVfModuleToHeatFilesEntry("4993493","49959499");
2431     }
2432     @Test(expected = Exception.class)
2433     public void getServiceToResourceCustomization(){
2434         cd.getServiceToResourceCustomization("4993493","599349","49900");
2435     }
2436     @Test(expected = Exception.class)
2437     public void getHeatFilesForVfModuleTest(){
2438         cd.getHeatFilesForVfModule("4993493");
2439     }
2440     @Test(expected = Exception.class)
2441     public void getHeatTemplateTest(){
2442         cd.getHeatTemplate("4993493","test","heat");
2443     }
2444
2445     @Test(expected = Exception.class)
2446     public void saveHeatTemplateTest(){
2447         HeatTemplate heat = new HeatTemplate();
2448         Set <HeatTemplateParam> paramSet = new HashSet<>();
2449         cd.saveHeatTemplate(heat,paramSet);
2450     }
2451     @Test(expected = Exception.class)
2452     public void getHeatEnvironmentTest(){
2453         cd.getHeatEnvironment("4993493","test","heat");
2454     }
2455     @Test(expected = Exception.class)
2456     public void getHeatEnvironment3Test(){
2457         cd.getHeatEnvironment("4993493","test");
2458     }
2459     @Test(expected = Exception.class)
2460     public void saveHeatEnvironmentTest(){
2461         HeatEnvironment en = new HeatEnvironment();
2462         cd.saveHeatEnvironment(en);
2463     }
2464     @Test(expected = Exception.class)
2465     public void saveHeatTemplate2Test(){
2466         HeatTemplate heat = new HeatTemplate();
2467         cd.saveHeatTemplate(heat);
2468     }
2469     @Test(expected = Exception.class)
2470     public void saveHeatFileTest(){
2471         HeatFiles hf = new HeatFiles();
2472         cd.saveHeatFile(hf);
2473     }
2474     @Test(expected = Exception.class)
2475     public void saveVnfRecipeTest(){
2476         VnfRecipe vr = new VnfRecipe();
2477         cd.saveVnfRecipe(vr);
2478     }
2479     @Test(expected = Exception.class)
2480     public void saveVnfComponentsRecipe(){
2481         VnfComponentsRecipe vr = new VnfComponentsRecipe();
2482         cd.saveVnfComponentsRecipe(vr);
2483     }
2484     @Test(expected = Exception.class)
2485     public void saveOrUpdateVnfResourceTest(){
2486         VnfResource vr = new VnfResource();
2487         cd.saveOrUpdateVnfResource(vr);
2488     }
2489     @Test(expected = Exception.class)
2490     public void saveVnfResourceCustomizationTest(){
2491         VnfResourceCustomization vr = new VnfResourceCustomization();
2492         cd.saveVnfResourceCustomization(vr);
2493     }
2494     @Test(expected = Exception.class)
2495     public void saveAllottedResourceCustomizationTest(){
2496         AllottedResourceCustomization arc = new AllottedResourceCustomization();
2497         cd.saveAllottedResourceCustomization(arc);
2498     }
2499     @Test(expected = Exception.class)
2500     public void saveAllottedResourceTest(){
2501         AllottedResource ar = new AllottedResource();
2502         cd.saveAllottedResource(ar);
2503     }
2504     @Test(expected = Exception.class)
2505     public void saveNetworkResourceTest() throws RecordNotFoundException {
2506         NetworkResource nr = new NetworkResource();
2507         cd.saveNetworkResource(nr);
2508     }
2509     @Test(expected = Exception.class)
2510     public void saveToscaCsarTest()throws RecordNotFoundException {
2511         ToscaCsar ts = new ToscaCsar();
2512         cd.saveToscaCsar(ts);
2513     }
2514     @Test(expected = Exception.class)
2515     public void getToscaCsar(){
2516         cd.getToscaCsar("4993493");
2517     }
2518     @Test(expected = Exception.class)
2519     public void saveTempNetworkHeatTemplateLookupTest(){
2520         TempNetworkHeatTemplateLookup t = new TempNetworkHeatTemplateLookup();
2521         cd.saveTempNetworkHeatTemplateLookup(t);
2522     }
2523     @Test(expected = Exception.class)
2524     public void saveVfModuleToHeatFiles(){
2525         VfModuleToHeatFiles v = new VfModuleToHeatFiles();
2526         cd.saveVfModuleToHeatFiles(v);
2527     }
2528     @Test(expected = Exception.class)
2529     public void saveVnfResourceToVfModuleCustomizationTest() throws RecordNotFoundException {
2530         VnfResourceCustomization v =new VnfResourceCustomization();
2531         VfModuleCustomization vm = new VfModuleCustomization();
2532         cd.saveVnfResourceToVfModuleCustomization(v, vm);
2533     }
2534     @Test(expected = Exception.class)
2535     public void saveNetworkResourceCustomizationTest() throws RecordNotFoundException {
2536         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
2537         cd.saveNetworkResourceCustomization(nrc);
2538     }
2539
2540     @Test(expected = Exception.class)
2541     public void saveServiceToNetworksTest(){
2542         AllottedResource ar = new AllottedResource();
2543         cd.saveAllottedResource(ar);
2544     }
2545     @Test(expected = Exception.class)
2546     public void saveServiceToResourceCustomizationTest(){
2547         ServiceToResourceCustomization ar = new ServiceToResourceCustomization();
2548         cd.saveServiceToResourceCustomization(ar);
2549     }
2550     @Test(expected = Exception.class)
2551     public void saveServiceTest(){
2552         Service ar = new Service();
2553         cd.saveService(ar);
2554     }
2555     @Test(expected = Exception.class)
2556     public void saveOrUpdateVfModuleTest(){
2557         VfModule ar = new VfModule();
2558         cd.saveOrUpdateVfModule(ar);
2559     }
2560     @Test(expected = Exception.class)
2561     public void saveOrUpdateVfModuleCustomizationTest(){
2562         VfModuleCustomization ar = new VfModuleCustomization();
2563         cd.saveOrUpdateVfModuleCustomization(ar);
2564     }
2565
2566     @Test(expected = Exception.class)
2567     public void getNestedHeatTemplateTest(){
2568         cd.getNestedHeatTemplate(101,201);
2569     }
2570     @Test(expected = Exception.class)
2571     public void getNestedHeatTemplate2Test(){
2572         cd.getNestedHeatTemplate("1002","1002");
2573     }
2574     @Test(expected = Exception.class)
2575     public void saveNestedHeatTemplateTest(){
2576         HeatTemplate ar = new HeatTemplate();
2577         cd.saveNestedHeatTemplate("1001",ar,"test");
2578     }
2579     @Test(expected = Exception.class)
2580     public void getHeatFiles2Test(){
2581         VfModuleCustomization ar = new VfModuleCustomization();
2582         cd.getHeatFiles(101,"test","1001","v2");
2583     }
2584     @Test(expected = Exception.class)
2585     public void getHeatFiles3Test(){
2586         VfModuleCustomization ar = new VfModuleCustomization();
2587         cd.getHeatFiles("200192");
2588     }
2589     @Test(expected = Exception.class)
2590     public void saveHeatFilesTest(){
2591         HeatFiles ar = new HeatFiles();
2592         cd.saveHeatFiles(ar);
2593     }
2594     @Test(expected = Exception.class)
2595     public void saveVfModuleToHeatFilesTest(){
2596         HeatFiles ar = new HeatFiles();
2597         cd.saveVfModuleToHeatFiles("3772893",ar);
2598     }
2599     @Test
2600     public void getNetworkResourceByModelUuidTest(){
2601
2602         cd.getNetworkResourceByModelUuid("3899291");
2603     }
2604     @Test(expected = Exception.class)
2605     public void getNetworkRecipeTest(){
2606
2607         cd.getNetworkRecipe("test","test1","test2");
2608     }
2609     @Test(expected = Exception.class)
2610     public void getNetworkRecipe2Test(){
2611
2612         cd.getNetworkRecipe("test","test1");
2613     }
2614     @Test
2615     public void getNetworkResourceByModelCustUuidTest(){
2616
2617         cd.getNetworkResourceByModelCustUuid("test");
2618     }
2619     @Test(expected = Exception.class)
2620     public void getVnfComponentsRecipe2Test(){
2621
2622         cd.getVnfComponentsRecipe("test1","test2","test3","test4");
2623     }
2624     @Test(expected = Exception.class)
2625     public void getVnfComponentsRecipeByVfModuleModelUUIdTest(){
2626
2627         cd.getVnfComponentsRecipeByVfModuleModelUUId("test1","test2","test3");
2628     }
2629     @Test(expected = Exception.class)
2630     public void getVnfComponentRecipesTest(){
2631
2632         cd.getVnfComponentRecipes("test");
2633     }
2634     @Test(expected = Exception.class)
2635     public void saveOrUpdateVnfComponentTest(){
2636         VnfComponent ar = new VnfComponent();
2637         cd.saveOrUpdateVnfComponent(ar);
2638     }
2639
2640     @Test(expected = Exception.class)
2641     public void getVfModule2Test(){
2642
2643         cd.getVfModule("test");
2644     }
2645     @Test(expected = Exception.class)
2646     public void getVfModuleByModelUUIDTest(){
2647
2648         cd.getVfModuleByModelUUID("test");
2649     }
2650     @Test(expected = Exception.class)
2651     public void getServiceRecipeByModelUUIDTest(){
2652
2653         cd.getServiceRecipeByModelUUID("test1","test2");
2654     }
2655     @Test(expected = Exception.class)
2656     public void getModelRecipeTest(){
2657
2658         cd.getModelRecipe("test1","test2","test3");
2659     }
2660     @Test(expected = Exception.class)
2661     public void healthCheck(){
2662
2663         cd.healthCheck();
2664     }
2665     @Test(expected = Exception.class)
2666     public void executeQuerySingleRow(){
2667         VnfComponent ar = new VnfComponent();
2668         HashMap<String, String> variables = new HashMap<>();
2669         cd.executeQuerySingleRow("tets",variables,false);
2670     }
2671     @Test(expected = Exception.class)
2672     public void executeQueryMultipleRows(){
2673         HashMap<String, String> variables = new HashMap<>();
2674         cd.executeQueryMultipleRows("select",variables,false);
2675     }
2676 }