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 static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertNull;
  27 import static org.junit.Assert.assertTrue;
  28
  29 import java.io.Serializable;
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.Collections;
  33 import java.util.HashMap;
  34 import java.util.HashSet;
  35 import java.util.List;
  36 import java.util.Set;
  37
  38 import org.hibernate.HibernateException;
  39 import org.hibernate.NonUniqueResultException;
  40 import org.hibernate.Query;
  41 import org.hibernate.Session;
  42 import org.junit.After;
  43 import org.junit.Assert;
  44 import org.junit.Before;
  45 import org.junit.Ignore;
  46 import org.junit.Rule;
  47 import org.junit.Test;
  48 import org.junit.rules.ExpectedException;
  49 import org.openecomp.mso.db.catalog.CatalogDatabase;
  50 import org.openecomp.mso.db.catalog.beans.*;
  51 import org.openecomp.mso.db.catalog.utils.RecordNotFoundException;
  52
  53 import mockit.Mock;
  54 import mockit.MockUp;
  55
  56 public class CatalogDatabaseTest {
  57
  58     CatalogDatabase cd = null;
  59     @Rule
  60     public ExpectedException thrown = ExpectedException.none();
  61     private MockUp<CatalogDatabase> mockCd = null;
  62     private MockUp<Session> mockedSession = null;
  63     private MockUp<Query> mockUpQuery = null;
  64     private MockUp<Query> mockUpQuery2 = null;
  65     private MockUp<Query> mockUpQuery3 = null;
  66     private MockUp<Query> mockUpQuery4 = null;
  67     @Before
  68     public void setup(){
  69         cd = CatalogDatabase.getInstance();
  70     }
  71
  72
  73          @After
  74          public void tearDown() {
  75                  if (mockCd!=null) { mockCd.tearDown(); mockCd = null; }
  76                  if (mockedSession!=null) { mockedSession.tearDown(); mockedSession = null; }
  77                  if (mockUpQuery!=null) { mockUpQuery.tearDown(); mockUpQuery = null; }
  78                  if (mockUpQuery2!=null) { mockUpQuery2.tearDown(); mockUpQuery2 = null; }
  79                  if (mockUpQuery3!=null) { mockUpQuery3.tearDown(); mockUpQuery3 = null; }
  80                  if (mockUpQuery4!=null) { mockUpQuery4.tearDown(); mockUpQuery4 = null; }
  81     }
  82
  83
  84
  85     @Test
  86     public void getAllHeatTemplatesTest(){
  87
  88         mockUpQuery = new MockUp<Query>() {
  89             @Mock
  90             public List<HeatTemplate> list() {
  91                 HeatTemplate heatTemplate = new HeatTemplate();
  92                 return Arrays.asList(heatTemplate);
  93             }
  94         };
  95
  96         mockedSession = new MockUp<Session>() {
  97             @Mock
  98             public Query createQuery(String hql) {
  99                 return mockUpQuery.getMockInstance();
 100             }
 101         };
 102
 103         mockCd = new MockUp<CatalogDatabase>() {
 104             @Mock
 105             private Session getSession() {
 106                 return mockedSession.getMockInstance();
 107             }
 108         };
 109
 110         List <HeatTemplate> list = cd.getAllHeatTemplates();
 111         assertEquals(list.size(), 1);
 112
 113
 114     }
 115
 116     @Test
 117     public void getHeatTemplateByIdTest(){
 118
 119         mockedSession = new MockUp<Session>() {
 120             @Mock
 121             public Object get(Class cls, Serializable id) {
 122                 HeatTemplate heatTemplate = new HeatTemplate();
 123                 heatTemplate.setAsdcUuid("123-uuid");
 124                 return heatTemplate;
 125             }
 126         };
 127
 128         mockCd = new MockUp<CatalogDatabase>() {
 129             @Mock
 130             private Session getSession() {
 131                 return mockedSession.getMockInstance();
 132             }
 133         };
 134
 135         HeatTemplate ht = cd.getHeatTemplate(10);
 136         assertEquals("123-uuid", ht.getAsdcUuid());
 137
 138
 139     }
 140
 141     @Test
 142     public void getHeatTemplateByNameEmptyListTest(){
 143
 144         mockUpQuery = new MockUp<Query>() {
 145             @Mock
 146             public List<HeatTemplate> list() {
 147                 HeatTemplate heatTemplate = new HeatTemplate();
 148                 return Arrays.asList();
 149             }
 150         };
 151
 152         mockedSession = new MockUp<Session>() {
 153             @Mock
 154             public Query createQuery(String hql) {
 155                 return mockUpQuery.getMockInstance();
 156             }
 157         };
 158
 159         mockCd = new MockUp<CatalogDatabase>() {
 160             @Mock
 161             private Session getSession() {
 162                 return mockedSession.getMockInstance();
 163             }
 164         };
 165
 166         HeatTemplate ht = cd.getHeatTemplate("heat123");
 167         assertEquals(null, ht);
 168
 169
 170     }
 171
 172     @Test
 173     public void getHeatTemplateByNameTest(){
 174
 175         mockUpQuery = new MockUp<Query>() {
 176             @Mock
 177             public List<HeatTemplate> list() {
 178                 HeatTemplate heatTemplate1 = new HeatTemplate();
 179                 heatTemplate1.setAsdcUuid("123-uuid");
 180                 heatTemplate1.setVersion("1.2");
 181                 HeatTemplate heatTemplate2 = new HeatTemplate();
 182                 heatTemplate2.setAsdcUuid("456-uuid");
 183                 heatTemplate2.setVersion("1.3");
 184                 return Arrays.asList(heatTemplate1, heatTemplate2);
 185             }
 186         };
 187
 188         mockedSession = new MockUp<Session>() {
 189             @Mock
 190             public Query createQuery(String hql) {
 191                 return mockUpQuery.getMockInstance();
 192             }
 193         };
 194
 195         mockCd = new MockUp<CatalogDatabase>() {
 196             @Mock
 197             private Session getSession() {
 198                 return mockedSession.getMockInstance();
 199             }
 200         };
 201
 202         HeatTemplate ht = cd.getHeatTemplate("heat123");
 203         assertEquals("456-uuid", ht.getAsdcUuid());
 204
 205
 206     }
 207
 208     @Test
 209     public void getHeatTemplateByTemplateNameTest() {
 210
 211         mockUpQuery = new MockUp<Query>() {
 212             @Mock
 213             public List<HeatTemplate> list() {
 214                 HeatTemplate heatTemplate = new HeatTemplate();
 215                 heatTemplate.setAsdcUuid("1234-uuid");
 216                 return Arrays.asList(heatTemplate);
 217             }
 218         };
 219
 220         mockedSession = new MockUp<Session>() {
 221             @Mock
 222             public Query createQuery(String hql) {
 223                 return mockUpQuery.getMockInstance();
 224             }
 225         };
 226
 227         mockCd = new MockUp<CatalogDatabase>() {
 228             @Mock
 229             private Session getSession() {
 230                 return mockedSession.getMockInstance();
 231             }
 232         };
 233
 234         HeatTemplate ht = cd.getHeatTemplate("heat123","v2");
 235         assertEquals("1234-uuid", ht.getAsdcUuid());
 236
 237
 238     }
 239
 240     @Test
 241     public void getHeatTemplateByTemplateNameEmptyResultTest() {
 242
 243         mockUpQuery = new MockUp<Query>() {
 244             @Mock
 245             public List<HeatTemplate> list() {
 246                 return Arrays.asList();
 247             }
 248         };
 249
 250         mockedSession = new MockUp<Session>() {
 251             @Mock
 252             public Query createQuery(String hql) {
 253                 return mockUpQuery.getMockInstance();
 254             }
 255         };
 256
 257         mockCd = new MockUp<CatalogDatabase>() {
 258             @Mock
 259             private Session getSession() {
 260                 return mockedSession.getMockInstance();
 261             }
 262         };
 263
 264         HeatTemplate ht = cd.getHeatTemplate("heat123","v2");
 265         assertEquals(null, ht);
 266
 267
 268     }
 269
 270     @Test
 271     public void getHeatTemplateByArtifactUuidException(){
 272
 273         mockedSession = new MockUp<Session>() {
 274             @Mock
 275             public Object get(Class cls, Serializable id) {
 276                 HeatTemplate heatTemplate = new HeatTemplate();
 277                 heatTemplate.setAsdcUuid("123-uuid");
 278                 return heatTemplate;
 279             }
 280         };
 281
 282         mockCd = new MockUp<CatalogDatabase>() {
 283             @Mock
 284             private Session getSession() {
 285                 return mockedSession.getMockInstance();
 286             }
 287         };
 288
 289         HeatTemplate ht = cd.getHeatTemplateByArtifactUuid("123");
 290         assertEquals("123-uuid", ht.getAsdcUuid());
 291
 292
 293     }
 294
 295     @Test
 296     public void getHeatTemplateByArtifactUuidTest(){
 297
 298         mockUpQuery = new MockUp<Query>() {
 299
 300             @Mock
 301             public Object uniqueResult() {
 302                 HeatTemplate heatTemplate = new HeatTemplate();
 303                 heatTemplate.setAsdcUuid("123-uuid");
 304                 return heatTemplate;
 305             }
 306         };
 307
 308         mockedSession = new MockUp<Session>() {
 309             @Mock
 310             public Query createQuery(String hql) {
 311                 return mockUpQuery.getMockInstance();
 312             }
 313         };
 314
 315         mockCd = new MockUp<CatalogDatabase>() {
 316             @Mock
 317             private Session getSession() {
 318                 return mockedSession.getMockInstance();
 319             }
 320         };
 321
 322         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 323         assertEquals("123-uuid", ht.getAsdcUuid());
 324
 325
 326     }
 327
 328     @Test
 329     public void getHeatTemplateByArtifactUuidNullTest(){
 330
 331         mockUpQuery = new MockUp<Query>() {
 332
 333             @Mock
 334             public Object uniqueResult() {
 335                 return null;
 336             }
 337         };
 338
 339         mockedSession = new MockUp<Session>() {
 340             @Mock
 341             public Query createQuery(String hql) {
 342                 return mockUpQuery.getMockInstance();
 343             }
 344         };
 345
 346         mockCd = new MockUp<CatalogDatabase>() {
 347             @Mock
 348             private Session getSession() {
 349                 return mockedSession.getMockInstance();
 350             }
 351         };
 352
 353         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 354         assertNull(ht);
 355
 356
 357     }
 358
 359     @Test
 360     public void getHeatTemplateByArtifactUuidHibernateErrorTest(){
 361
 362         mockUpQuery = new MockUp<Query>() {
 363
 364             @Mock
 365             public Object uniqueResult() {
 366                 throw new HibernateException("hibernate exception");
 367             }
 368         };
 369
 370         mockedSession = new MockUp<Session>() {
 371             @Mock
 372             public Query createQuery(String hql) {
 373                 return mockUpQuery.getMockInstance();
 374             }
 375         };
 376
 377         mockCd = new MockUp<CatalogDatabase>() {
 378             @Mock
 379             private Session getSession() {
 380                 return mockedSession.getMockInstance();
 381             }
 382         };
 383         thrown.expect(HibernateException.class);
 384         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 385
 386
 387     }
 388
 389     @Test
 390     public void getHeatTemplateByArtifactUuidNonUniqueResultTest(){
 391
 392         mockUpQuery = new MockUp<Query>() {
 393
 394             @Mock
 395             public Object uniqueResult() {
 396                 throw new NonUniqueResultException(2);
 397             }
 398         };
 399
 400         mockedSession = new MockUp<Session>() {
 401             @Mock
 402             public Query createQuery(String hql) {
 403                 return mockUpQuery.getMockInstance();
 404             }
 405         };
 406
 407         mockCd = new MockUp<CatalogDatabase>() {
 408             @Mock
 409             private Session getSession() {
 410                 return mockedSession.getMockInstance();
 411             }
 412         };
 413         thrown.expect(NonUniqueResultException.class);
 414         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 415
 416
 417     }
 418
 419     @Test
 420     public void getHeatTemplateByArtifactUuidGenericExceptionTest(){
 421
 422         mockUpQuery = new MockUp<Query>() {
 423
 424             @Mock
 425             public Object uniqueResult() throws Exception {
 426                 throw new Exception();
 427             }
 428         };
 429
 430         mockedSession = new MockUp<Session>() {
 431             @Mock
 432             public Query createQuery(String hql) {
 433                 return mockUpQuery.getMockInstance();
 434             }
 435         };
 436
 437         mockCd = new MockUp<CatalogDatabase>() {
 438             @Mock
 439             private Session getSession() {
 440                 return mockedSession.getMockInstance();
 441             }
 442         };
 443         thrown.expect(Exception.class);
 444         HeatTemplate ht = cd.getHeatTemplateByArtifactUuidRegularQuery("123-uuid");
 445
 446
 447     }
 448
 449     @Test
 450     public void getParametersForHeatTemplateTest(){
 451
 452         mockUpQuery = new MockUp<Query>() {
 453             @Mock
 454             public List<HeatTemplate> list() {
 455                 HeatTemplate heatTemplate = new HeatTemplate();
 456                 heatTemplate.setAsdcUuid("1234-uuid");
 457                 return Arrays.asList(heatTemplate);
 458             }
 459         };
 460
 461         mockedSession = new MockUp<Session>() {
 462             @Mock
 463             public Query createQuery(String hql) {
 464                 return mockUpQuery.getMockInstance();
 465             }
 466         };
 467
 468         mockCd = new MockUp<CatalogDatabase>() {
 469             @Mock
 470             private Session getSession() {
 471                 return mockedSession.getMockInstance();
 472             }
 473         };
 474
 475         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 476         assertEquals(1, htList.size());
 477
 478
 479     }
 480
 481     @Test
 482     public void getParametersForHeatTemplateHibernateExceptionTest(){
 483
 484         mockUpQuery = new MockUp<Query>() {
 485             @Mock
 486             public List<HeatTemplate> list() {
 487                 throw new HibernateException("hibernate exception");
 488             }
 489         };
 490
 491         mockedSession = new MockUp<Session>() {
 492             @Mock
 493             public Query createQuery(String hql) {
 494                 return mockUpQuery.getMockInstance();
 495             }
 496         };
 497
 498         mockCd = new MockUp<CatalogDatabase>() {
 499             @Mock
 500             private Session getSession() {
 501                 return mockedSession.getMockInstance();
 502             }
 503         };
 504         thrown.expect(HibernateException.class);
 505         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 506
 507
 508
 509     }
 510
 511     @Test
 512     public void getParametersForHeatTemplateExceptionTest(){
 513
 514         mockUpQuery = new MockUp<Query>() {
 515             @Mock
 516             public List<HeatTemplate> list() throws Exception {
 517                 throw new Exception();
 518             }
 519         };
 520
 521         mockedSession = new MockUp<Session>() {
 522             @Mock
 523             public Query createQuery(String hql) {
 524                 return mockUpQuery.getMockInstance();
 525             }
 526         };
 527
 528         mockCd = new MockUp<CatalogDatabase>() {
 529             @Mock
 530             private Session getSession() {
 531                 return mockedSession.getMockInstance();
 532             }
 533         };
 534         thrown.expect(Exception.class);
 535         List<HeatTemplateParam> htList = cd.getParametersForHeatTemplate("12l3");
 536
 537
 538     }
 539
 540     @Test
 541     public void getHeatEnvironmentByArtifactUuidTest(){
 542
 543         mockUpQuery = new MockUp<Query>() {
 544
 545             @Mock
 546             public Object uniqueResult() {
 547                 HeatEnvironment heatEnvironment = new HeatEnvironment();
 548                 heatEnvironment.setArtifactUuid("123-uuid");
 549                 return heatEnvironment;
 550             }
 551         };
 552
 553         mockedSession = new MockUp<Session>() {
 554             @Mock
 555             public Query createQuery(String hql) {
 556                 return mockUpQuery.getMockInstance();
 557             }
 558         };
 559
 560         mockCd = new MockUp<CatalogDatabase>() {
 561             @Mock
 562             private Session getSession() {
 563                 return mockedSession.getMockInstance();
 564             }
 565         };
 566
 567         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 568         assertEquals("123-uuid", he.getArtifactUuid());
 569
 570
 571     }
 572
 573     @Test
 574     public void getHeatEnvironmentByArtifactUuidHibernateExceptionTest(){
 575
 576         mockUpQuery = new MockUp<Query>() {
 577
 578             @Mock
 579             public Object uniqueResult() {
 580                 throw new HibernateException("hibernate exception");
 581             }
 582         };
 583
 584         mockedSession = new MockUp<Session>() {
 585             @Mock
 586             public Query createQuery(String hql) {
 587                 return mockUpQuery.getMockInstance();
 588             }
 589         };
 590
 591         mockCd = new MockUp<CatalogDatabase>() {
 592             @Mock
 593             private Session getSession() {
 594                 return mockedSession.getMockInstance();
 595             }
 596         };
 597         thrown.expect(HibernateException.class);
 598         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 599
 600
 601     }
 602
 603     @Test
 604     public void getHeatEnvironmentByArtifactUuidExceptionTest(){
 605
 606         mockUpQuery = new MockUp<Query>() {
 607
 608             @Mock
 609             public Object uniqueResult() throws Exception {
 610                 throw new Exception();
 611             }
 612         };
 613
 614         mockedSession = new MockUp<Session>() {
 615             @Mock
 616             public Query createQuery(String hql) {
 617                 return mockUpQuery.getMockInstance();
 618             }
 619         };
 620
 621         mockCd = new MockUp<CatalogDatabase>() {
 622             @Mock
 623             private Session getSession() {
 624                 return mockedSession.getMockInstance();
 625             }
 626         };
 627         thrown.expect(Exception.class);
 628         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 629
 630
 631     }
 632
 633     @Test
 634     public void getHeatEnvironmentByArtifactUuidNonUniqueTest(){
 635
 636         mockUpQuery = new MockUp<Query>() {
 637
 638             @Mock
 639             public Object uniqueResult() throws Exception {
 640                 throw new org.hibernate.NonUniqueResultException(2);
 641             }
 642         };
 643
 644         mockedSession = new MockUp<Session>() {
 645             @Mock
 646             public Query createQuery(String hql) {
 647                 return mockUpQuery.getMockInstance();
 648             }
 649         };
 650
 651         mockCd = new MockUp<CatalogDatabase>() {
 652             @Mock
 653             private Session getSession() {
 654                 return mockedSession.getMockInstance();
 655             }
 656         };
 657
 658         HeatEnvironment he = cd.getHeatEnvironmentByArtifactUuid("123");
 659         assertNull(he);
 660
 661     }
 662
 663     @Test
 664     public void getServiceByInvariantUUIDTest(){
 665
 666         mockUpQuery = new MockUp<Query>() {
 667
 668             @Mock
 669             public List<Service> list() {
 670                 Service service = new Service();
 671                 service.setModelUUID("123-uuid");
 672                 return Arrays.asList(service);
 673             }
 674         };
 675
 676         mockedSession = new MockUp<Session>() {
 677             @Mock
 678             public Query createQuery(String hql) {
 679                 return mockUpQuery.getMockInstance();
 680             }
 681         };
 682
 683         mockCd = new MockUp<CatalogDatabase>() {
 684             @Mock
 685             private Session getSession() {
 686                 return mockedSession.getMockInstance();
 687             }
 688         };
 689
 690         Service service = cd.getServiceByInvariantUUID("123");
 691         assertEquals("123-uuid", service.getModelUUID());
 692
 693
 694     }
 695
 696     @Test
 697     public void getServiceByInvariantUUIDEmptyResultTest(){
 698
 699         mockUpQuery = new MockUp<Query>() {
 700
 701             @Mock
 702             public List<Service> list() {
 703                 return Arrays.asList();
 704             }
 705         };
 706
 707         mockedSession = new MockUp<Session>() {
 708             @Mock
 709             public Query createQuery(String hql) {
 710                 return mockUpQuery.getMockInstance();
 711             }
 712         };
 713
 714         mockCd = new MockUp<CatalogDatabase>() {
 715             @Mock
 716             private Session getSession() {
 717                 return mockedSession.getMockInstance();
 718             }
 719         };
 720
 721         Service service = cd.getServiceByInvariantUUID("123");
 722         assertEquals(null, service);
 723
 724
 725     }
 726
 727     @Test
 728     public void getServiceTest(){
 729
 730         mockUpQuery = new MockUp<Query>() {
 731
 732             @Mock
 733             public Object uniqueResult() throws Exception {
 734                 Service service = new Service();
 735                 service.setModelUUID("123-uuid");
 736                 return service;
 737             }
 738         };
 739
 740         mockedSession = new MockUp<Session>() {
 741             @Mock
 742             public Query createQuery(String hql) {
 743                 return mockUpQuery.getMockInstance();
 744             }
 745         };
 746
 747         mockCd = new MockUp<CatalogDatabase>() {
 748             @Mock
 749             private Session getSession() {
 750                 return mockedSession.getMockInstance();
 751             }
 752         };
 753
 754         Service service = cd.getService("123");
 755         assertEquals("123-uuid", service.getModelUUID());
 756
 757
 758     }
 759
 760     @Test
 761     public void getServiceNullTest(){
 762
 763         mockUpQuery = new MockUp<Query>() {
 764
 765             @Mock
 766             public Object uniqueResult() throws Exception {
 767                 return null;
 768             }
 769         };
 770
 771         mockedSession = new MockUp<Session>() {
 772             @Mock
 773             public Query createQuery(String hql) {
 774                 return mockUpQuery.getMockInstance();
 775             }
 776         };
 777
 778         mockCd = new MockUp<CatalogDatabase>() {
 779             @Mock
 780             private Session getSession() {
 781                 return mockedSession.getMockInstance();
 782             }
 783         };
 784
 785         Service service = cd.getService("123");
 786         assertNull(service);
 787
 788
 789     }
 790
 791     @Test
 792     public void getServiceNoUniqueResultTest(){
 793
 794         mockUpQuery = new MockUp<Query>() {
 795
 796             @Mock
 797             public Object uniqueResult() throws Exception {
 798                 throw new NonUniqueResultException(-1);
 799             }
 800         };
 801
 802         mockedSession = new MockUp<Session>() {
 803             @Mock
 804             public Query createQuery(String hql) {
 805                 return mockUpQuery.getMockInstance();
 806             }
 807         };
 808
 809         mockCd = new MockUp<CatalogDatabase>() {
 810             @Mock
 811             private Session getSession() {
 812                 return mockedSession.getMockInstance();
 813             }
 814         };
 815         thrown.expect(NonUniqueResultException.class);
 816         Service service = cd.getService("123");
 817
 818
 819     }
 820
 821     @Test
 822     public void getServiceHibernateExceptionTest(){
 823
 824         mockUpQuery = new MockUp<Query>() {
 825
 826             @Mock
 827             public Object uniqueResult() throws Exception {
 828                 throw new HibernateException("hibernate exception");
 829             }
 830         };
 831
 832         mockedSession = new MockUp<Session>() {
 833             @Mock
 834             public Query createQuery(String hql) {
 835                 return mockUpQuery.getMockInstance();
 836             }
 837         };
 838
 839         mockCd = new MockUp<CatalogDatabase>() {
 840             @Mock
 841             private Session getSession() {
 842                 return mockedSession.getMockInstance();
 843             }
 844         };
 845         thrown.expect(HibernateException.class);
 846         Service service = cd.getService("123");
 847
 848
 849     }
 850
 851     @Test
 852     public void getServiceExceptionTest(){
 853
 854         mockUpQuery = new MockUp<Query>() {
 855
 856             @Mock
 857             public Object uniqueResult() throws Exception {
 858                 throw new Exception("generic exception");
 859             }
 860         };
 861
 862         mockedSession = new MockUp<Session>() {
 863             @Mock
 864             public Query createQuery(String hql) {
 865                 return mockUpQuery.getMockInstance();
 866             }
 867         };
 868
 869         mockCd = new MockUp<CatalogDatabase>() {
 870             @Mock
 871             private Session getSession() {
 872                 return mockedSession.getMockInstance();
 873             }
 874         };
 875         thrown.expect(Exception.class);
 876         Service service = cd.getService("123");
 877
 878
 879     }
 880
 881     @Test
 882     public void getServiceByModelUUIDTest(){
 883
 884         mockUpQuery = new MockUp<Query>() {
 885
 886             @Mock
 887             public Object uniqueResult() throws Exception {
 888                 Service service = new Service();
 889                 service.setModelUUID("123-uuid");
 890                 return service;
 891             }
 892         };
 893
 894         mockedSession = new MockUp<Session>() {
 895             @Mock
 896             public Query createQuery(String hql) {
 897                 return mockUpQuery.getMockInstance();
 898             }
 899         };
 900
 901         mockCd = new MockUp<CatalogDatabase>() {
 902             @Mock
 903             private Session getSession() {
 904                 return mockedSession.getMockInstance();
 905             }
 906         };
 907         Service service = cd.getServiceByModelUUID("123");
 908         assertEquals("123-uuid", service.getModelUUID());
 909
 910
 911     }
 912
 913     @Test
 914     public void getService2Test(){
 915         mockUpQuery = new MockUp<Query>() {
 916
 917             @Mock
 918             public Object uniqueResult() throws Exception {
 919                 Service service = new Service();
 920                 service.setModelUUID("123-uuid");
 921                 return service;
 922             }
 923         };
 924
 925         mockedSession = new MockUp<Session>() {
 926             @Mock
 927             public Query createQuery(String hql) {
 928                 return mockUpQuery.getMockInstance();
 929             }
 930         };
 931
 932         mockCd = new MockUp<CatalogDatabase>() {
 933             @Mock
 934             private Session getSession() {
 935                 return mockedSession.getMockInstance();
 936             }
 937         };
 938
 939         HashMap<String, String> map = new HashMap<>();
 940         map.put("serviceNameVersionId", "v2");
 941         Service service = cd.getService(map, "123");
 942
 943         assertEquals("123-uuid", service.getModelUUID());
 944
 945         map.remove("serviceNameVersionId");
 946         service = cd.getService(map, "123");
 947         assertNotNull(service);
 948     }
 949
 950     @Test
 951     public void getService2NonUniqueTest(){
 952         mockUpQuery = new MockUp<Query>() {
 953
 954             @Mock
 955             public Object uniqueResult() throws Exception {
 956                 throw new org.hibernate.NonUniqueResultException(2);
 957             }
 958         };
 959
 960         mockedSession = new MockUp<Session>() {
 961             @Mock
 962             public Query createQuery(String hql) {
 963                 return mockUpQuery.getMockInstance();
 964             }
 965         };
 966
 967         mockCd = new MockUp<CatalogDatabase>() {
 968             @Mock
 969             private Session getSession() {
 970                 return mockedSession.getMockInstance();
 971             }
 972         };
 973
 974         HashMap<String, String> map = new HashMap<>();
 975         map.put("serviceNameVersionId", "v2");
 976
 977         thrown.expect(org.hibernate.NonUniqueResultException.class);
 978         Service service = cd.getService(map, "123");
 979     }
 980
 981     @Test
 982     public void getService2HibernateExceptionTest(){
 983         mockUpQuery = new MockUp<Query>() {
 984
 985             @Mock
 986             public Object uniqueResult() throws Exception {
 987                 throw new org.hibernate.HibernateException("test case");
 988             }
 989         };
 990
 991         mockedSession = new MockUp<Session>() {
 992             @Mock
 993             public Query createQuery(String hql) {
 994                 return mockUpQuery.getMockInstance();
 995             }
 996         };
 997
 998         mockCd = new MockUp<CatalogDatabase>() {
 999             @Mock
1000             private Session getSession() {
1001                 return mockedSession.getMockInstance();
1002             }
1003         };
1004
1005         HashMap<String, String> map = new HashMap<>();
1006         map.put("serviceNameVersionId", "v2");
1007
1008         thrown.expect(org.hibernate.HibernateException.class);
1009         Service service = cd.getService(map, "123");
1010     }
1011
1012     @Test
1013     public void getService2ExceptionTest(){
1014         mockUpQuery = new MockUp<Query>() {
1015
1016                 @Mock
1017             public Object uniqueResult() throws Exception {
1018                 throw new NullPointerException();
1019             }
1020         };
1021
1022         mockedSession = new MockUp<Session>() {
1023             @Mock
1024             public Query createQuery(String hql) {
1025                 return mockUpQuery.getMockInstance();
1026             }
1027         };
1028
1029         mockCd = new MockUp<CatalogDatabase>() {
1030             @Mock
1031             private Session getSession() {
1032                 return mockedSession.getMockInstance();
1033             }
1034         };
1035
1036         HashMap<String, String> map = new HashMap<>();
1037         map.put("serviceNameVersionId", "v2");
1038
1039         thrown.expect(NullPointerException.class);
1040         Service service = cd.getService(map, "123");
1041     }
1042
1043     @Test
1044     public void getService2NullTest(){
1045         mockUpQuery = new MockUp<Query>() {
1046
1047             @Mock
1048             public Object uniqueResult() throws Exception {
1049                 return null;
1050             }
1051         };
1052
1053         mockedSession = new MockUp<Session>() {
1054             @Mock
1055             public Query createQuery(String hql) {
1056                 return mockUpQuery.getMockInstance();
1057             }
1058         };
1059
1060         mockCd = new MockUp<CatalogDatabase>() {
1061             @Mock
1062             private Session getSession() {
1063                 return mockedSession.getMockInstance();
1064             }
1065         };
1066
1067         HashMap<String, String> map = new HashMap<>();
1068         map.put("serviceNameVersionId", "v2");
1069
1070         Service service = cd.getService(map, "123");
1071         assertNull(service);
1072     }
1073
1074     @Test
1075     public void getServiceByModelNameTest(){
1076
1077         mockUpQuery = new MockUp<Query>() {
1078             @Mock
1079             public List<Service> list() throws Exception {
1080                 Service service = new Service();
1081                 service.setModelUUID("123-uuid");
1082                 return Arrays.asList(service);
1083             }
1084         };
1085
1086         mockedSession = new MockUp<Session>() {
1087             @Mock
1088             public Query createQuery(String hql) {
1089                 return mockUpQuery.getMockInstance();
1090             }
1091         };
1092
1093         mockCd = new MockUp<CatalogDatabase>() {
1094             @Mock
1095             private Session getSession() {
1096                 return mockedSession.getMockInstance();
1097             }
1098         };
1099
1100         Service service = cd.getServiceByModelName("123");
1101         assertEquals("123-uuid", service.getModelUUID());
1102
1103
1104     }
1105
1106     @Test
1107     public void getServiceByModelNameEmptyTest(){
1108
1109         mockUpQuery = new MockUp<Query>() {
1110             @Mock
1111             public List<Service> list() throws Exception {
1112                 return Arrays.asList();
1113             }
1114         };
1115
1116         mockedSession = new MockUp<Session>() {
1117             @Mock
1118             public Query createQuery(String hql) {
1119                 return mockUpQuery.getMockInstance();
1120             }
1121         };
1122
1123         mockCd = new MockUp<CatalogDatabase>() {
1124             @Mock
1125             private Session getSession() {
1126                 return mockedSession.getMockInstance();
1127             }
1128         };
1129
1130         Service service = cd.getServiceByModelName("123");
1131         assertEquals(null, service);
1132
1133
1134     }
1135
1136     @Test
1137     public void getServiceByVersionAndInvariantIdTest() throws Exception{
1138
1139         mockUpQuery = new MockUp<Query>() {
1140
1141             @Mock
1142             public Object uniqueResult() throws Exception {
1143                 Service service = new Service();
1144                 service.setModelUUID("123-uuid");
1145                 return service;
1146             }
1147         };
1148
1149         mockedSession = new MockUp<Session>() {
1150             @Mock
1151             public Query createQuery(String hql) {
1152                 return mockUpQuery.getMockInstance();
1153             }
1154         };
1155
1156         mockCd = new MockUp<CatalogDatabase>() {
1157             @Mock
1158             private Session getSession() {
1159                 return mockedSession.getMockInstance();
1160             }
1161         };
1162         Service service = cd.getServiceByVersionAndInvariantId("123","tetwe");
1163         assertEquals("123-uuid", service.getModelUUID());
1164
1165
1166     }
1167
1168     @Test
1169     public void getServiceByVersionAndInvariantIdNullTest() throws Exception{
1170
1171         mockUpQuery = new MockUp<Query>() {
1172
1173             @Mock
1174             public Object uniqueResult() throws Exception {
1175                 return null;
1176             }
1177         };
1178
1179         mockedSession = new MockUp<Session>() {
1180             @Mock
1181             public Query createQuery(String hql) {
1182                 return mockUpQuery.getMockInstance();
1183             }
1184         };
1185
1186         mockCd = new MockUp<CatalogDatabase>() {
1187             @Mock
1188             private Session getSession() {
1189                 return mockedSession.getMockInstance();
1190             }
1191         };
1192         Service service = cd.getServiceByVersionAndInvariantId("123","tetwe");
1193         assertNull(service);
1194
1195
1196     }
1197
1198     @Test
1199     public void getServiceByVersionAndInvariantIdNonUniqueResultTest() throws Exception{
1200
1201         mockUpQuery = new MockUp<Query>() {
1202
1203             @Mock
1204             public Object uniqueResult() throws Exception {
1205                 throw new NonUniqueResultException(-1);
1206             }
1207         };
1208
1209         mockedSession = new MockUp<Session>() {
1210             @Mock
1211             public Query createQuery(String hql) {
1212                 return mockUpQuery.getMockInstance();
1213             }
1214         };
1215
1216         mockCd = new MockUp<CatalogDatabase>() {
1217             @Mock
1218             private Session getSession() {
1219                 return mockedSession.getMockInstance();
1220             }
1221         };
1222         thrown.expect(Exception.class);
1223         Service service = cd.getServiceByVersionAndInvariantId("123","tetwe");
1224
1225
1226     }
1227
1228     @Test
1229     public void getServiceRecipeTestException() throws Exception{
1230         thrown.expect(Exception.class);
1231         ServiceRecipe ht = cd.getServiceRecipe("123","tetwe");
1232     }
1233
1234     @Test
1235     public void getServiceRecipeByServiceModelUuidTest() {
1236         mockUpQuery = new MockUp<Query>() {
1237             @Mock
1238             public List<ServiceRecipe> list() throws Exception {
1239                 ServiceRecipe serviceRecipe = new ServiceRecipe();
1240                 serviceRecipe.setId(1);
1241                 return Arrays.asList(serviceRecipe);
1242             }
1243         };
1244
1245         mockedSession = new MockUp<Session>() {
1246             @Mock
1247             public Query createQuery(String hql) {
1248                 return mockUpQuery.getMockInstance();
1249             }
1250         };
1251
1252         mockCd = new MockUp<CatalogDatabase>() {
1253             @Mock
1254             private Session getSession() {
1255                 return mockedSession.getMockInstance();
1256             }
1257         };
1258         ServiceRecipe serviceRecipe = cd.getServiceRecipeByServiceModelUuid("123","tetwe");
1259         assertEquals(1, serviceRecipe.getId());
1260
1261         serviceRecipe = cd.getServiceRecipeByServiceModelUuid("123", null);
1262         assertEquals(1, serviceRecipe.getId());
1263     }
1264
1265     @Test
1266     public void getServiceRecipeByServiceModelUuidEmptyTest() {
1267         mockUpQuery = new MockUp<Query>() {
1268             @Mock
1269             public List<ServiceRecipe> list() throws Exception {
1270                 return Arrays.asList();
1271             }
1272         };
1273
1274         mockedSession = new MockUp<Session>() {
1275             @Mock
1276             public Query createQuery(String hql) {
1277                 return mockUpQuery.getMockInstance();
1278             }
1279         };
1280
1281         mockCd = new MockUp<CatalogDatabase>() {
1282             @Mock
1283             private Session getSession() {
1284                 return mockedSession.getMockInstance();
1285             }
1286         };
1287         ServiceRecipe serviceRecipe = cd.getServiceRecipeByServiceModelUuid("123","tetwe");
1288         assertEquals(null, serviceRecipe);
1289
1290
1291     }
1292
1293     @Test
1294     public void getServiceRecipesTestException() throws Exception{
1295         mockUpQuery = new MockUp<Query>() {
1296             @Mock
1297             public List<ServiceRecipe> list() {
1298                 ServiceRecipe serviceRecipe = new ServiceRecipe();
1299                 serviceRecipe.setId(1);
1300                 return Arrays.asList(serviceRecipe);
1301             }
1302         };
1303
1304         mockedSession = new MockUp<Session>() {
1305             @Mock
1306             public Query createQuery(String hql) {
1307                 return mockUpQuery.getMockInstance();
1308             }
1309         };
1310
1311         mockCd = new MockUp<CatalogDatabase>() {
1312             @Mock
1313             private Session getSession() {
1314                 return mockedSession.getMockInstance();
1315             }
1316         };
1317         List<ServiceRecipe> serviceRecipes = cd.getServiceRecipes("123");
1318         assertEquals(1, serviceRecipes.size());
1319
1320
1321     }
1322
1323     @Test
1324     public void getServiceRecipesEmptyTest() throws Exception{
1325         mockUpQuery = new MockUp<Query>() {
1326             @Mock
1327             public List<ServiceRecipe> list() {
1328                 return Arrays.asList();
1329             }
1330         };
1331
1332         mockedSession = new MockUp<Session>() {
1333             @Mock
1334             public Query createQuery(String hql) {
1335                 return mockUpQuery.getMockInstance();
1336             }
1337         };
1338
1339         mockCd = new MockUp<CatalogDatabase>() {
1340             @Mock
1341             private Session getSession() {
1342                 return mockedSession.getMockInstance();
1343             }
1344         };
1345         List<ServiceRecipe> serviceRecipes = cd.getServiceRecipes("123");
1346         assertEquals(0, serviceRecipes.size());
1347
1348
1349     }
1350
1351     @Test
1352     public void getVnfComponentTest() throws Exception{
1353         mockUpQuery = new MockUp<Query>() {
1354             @Mock
1355             public Object uniqueResult() {
1356                 VnfComponent vnfComponent = new VnfComponent();
1357                 vnfComponent.setHeatTemplateId(1234);
1358                 return vnfComponent;
1359             }
1360         };
1361
1362         mockedSession = new MockUp<Session>() {
1363             @Mock
1364             public Query createQuery(String hql) {
1365                 return mockUpQuery.getMockInstance();
1366             }
1367         };
1368
1369         mockCd = new MockUp<CatalogDatabase>() {
1370             @Mock
1371             private Session getSession() {
1372                 return mockedSession.getMockInstance();
1373             }
1374         };
1375
1376         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1377         assertEquals(new Integer(1234), ht.getHeatTemplateId());
1378     }
1379
1380     @Test
1381     public void getVnfComponentNullTest() throws Exception{
1382         mockUpQuery = new MockUp<Query>() {
1383             @Mock
1384             public Object uniqueResult() {
1385                 return null;
1386             }
1387         };
1388
1389         mockedSession = new MockUp<Session>() {
1390             @Mock
1391             public Query createQuery(String hql) {
1392                 return mockUpQuery.getMockInstance();
1393             }
1394         };
1395
1396         mockCd = new MockUp<CatalogDatabase>() {
1397             @Mock
1398             private Session getSession() {
1399                 return mockedSession.getMockInstance();
1400             }
1401         };
1402
1403         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1404         assertNull(ht);
1405     }
1406
1407     @Test
1408     public void getVnfComponentNonUniqueTest() throws Exception{
1409         mockUpQuery = new MockUp<Query>() {
1410             @Mock
1411             public Object uniqueResult() {
1412                 throw new org.hibernate.NonUniqueResultException(2);
1413             }
1414         };
1415
1416         mockedSession = new MockUp<Session>() {
1417             @Mock
1418             public Query createQuery(String hql) {
1419                 return mockUpQuery.getMockInstance();
1420             }
1421         };
1422
1423         mockCd = new MockUp<CatalogDatabase>() {
1424             @Mock
1425             private Session getSession() {
1426                 return mockedSession.getMockInstance();
1427             }
1428         };
1429
1430         thrown.expect(org.hibernate.NonUniqueResultException.class);
1431         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1432     }
1433
1434     @Test
1435     public void getVnfComponentHibernateExceptionTest() throws Exception{
1436         mockUpQuery = new MockUp<Query>() {
1437             @Mock
1438             public Object uniqueResult() {
1439                 throw new org.hibernate.HibernateException("test case");
1440             }
1441         };
1442
1443         mockedSession = new MockUp<Session>() {
1444             @Mock
1445             public Query createQuery(String hql) {
1446                 return mockUpQuery.getMockInstance();
1447             }
1448         };
1449
1450         mockCd = new MockUp<CatalogDatabase>() {
1451             @Mock
1452             private Session getSession() {
1453                 return mockedSession.getMockInstance();
1454             }
1455         };
1456
1457         thrown.expect(org.hibernate.HibernateException.class);
1458         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1459     }
1460
1461     @Test
1462     public void getVnfComponentExceptionTest() throws Exception{
1463         mockUpQuery = new MockUp<Query>() {
1464             @Mock
1465             public Object uniqueResult() {
1466                 throw new NullPointerException();
1467             }
1468         };
1469
1470         mockedSession = new MockUp<Session>() {
1471             @Mock
1472             public Query createQuery(String hql) {
1473                 return mockUpQuery.getMockInstance();
1474             }
1475         };
1476
1477         mockCd = new MockUp<CatalogDatabase>() {
1478             @Mock
1479             private Session getSession() {
1480                 return mockedSession.getMockInstance();
1481             }
1482         };
1483
1484         thrown.expect(NullPointerException.class);
1485         VnfComponent ht = cd.getVnfComponent(123,"vnf");
1486     }
1487
1488     @Test
1489     public void getVnfResourceTest() throws Exception{
1490         mockUpQuery = new MockUp<Query>() {
1491             @Mock
1492             public List<VnfResource> list() {
1493                 VnfResource vnfResource = new VnfResource();
1494                 vnfResource.setModelUuid("123-uuid");
1495                 return Arrays.asList(vnfResource);
1496             }
1497         };
1498
1499         mockedSession = new MockUp<Session>() {
1500             @Mock
1501             public Query createQuery(String hql) {
1502                 return mockUpQuery.getMockInstance();
1503             }
1504         };
1505
1506         mockCd = new MockUp<CatalogDatabase>() {
1507             @Mock
1508             private Session getSession() {
1509                 return mockedSession.getMockInstance();
1510             }
1511         };
1512         VnfResource vnfResource = cd.getVnfResourceByType("vnf");
1513         assertEquals("123-uuid", vnfResource.getModelUuid());
1514
1515
1516     }
1517
1518     @Test
1519     public void getVnfResourceEmptyTest() throws Exception{
1520         mockUpQuery = new MockUp<Query>() {
1521             @Mock
1522             public List<VnfResource> list() {
1523                 return Arrays.asList();
1524             }
1525         };
1526
1527         mockedSession = new MockUp<Session>() {
1528             @Mock
1529             public Query createQuery(String hql) {
1530                 return mockUpQuery.getMockInstance();
1531             }
1532         };
1533
1534         mockCd = new MockUp<CatalogDatabase>() {
1535             @Mock
1536             private Session getSession() {
1537                 return mockedSession.getMockInstance();
1538             }
1539         };
1540         VnfResource vnfResource = cd.getVnfResourceByType("vnf");
1541         assertEquals(null, vnfResource);
1542
1543
1544     }
1545
1546     @Test
1547     public void getVnfResourceByTypeTest() {
1548         mockUpQuery = new MockUp<Query>() {
1549
1550             @Mock
1551             public Object uniqueResult() {
1552                 VnfResource vnfResource = new VnfResource();
1553                 vnfResource.setModelUuid("123-uuid");
1554                 return vnfResource;
1555             }
1556         };
1557
1558         mockedSession = new MockUp<Session>() {
1559             @Mock
1560             public Query createQuery(String hql) {
1561                 return mockUpQuery.getMockInstance();
1562             }
1563         };
1564
1565         mockCd = new MockUp<CatalogDatabase>() {
1566             @Mock
1567             private Session getSession() {
1568                 return mockedSession.getMockInstance();
1569             }
1570         };
1571         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1572         assertEquals("123-uuid", vnfResource.getModelUuid());
1573
1574
1575     }
1576
1577     @Test
1578     public void getVnfResourceNURExceptionTest() {
1579         mockUpQuery = new MockUp<Query>() {
1580
1581             @Mock
1582             public Object uniqueResult() {
1583                 throw new NonUniqueResultException(-1);
1584             }
1585         };
1586
1587         mockedSession = new MockUp<Session>() {
1588             @Mock
1589             public Query createQuery(String hql) {
1590                 return mockUpQuery.getMockInstance();
1591             }
1592         };
1593
1594         mockCd = new MockUp<CatalogDatabase>() {
1595             @Mock
1596             private Session getSession() {
1597                 return mockedSession.getMockInstance();
1598             }
1599         };
1600         thrown.expect(NonUniqueResultException.class);
1601         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1602
1603
1604     }
1605
1606     @Test
1607     public void getVnfResourceHibernateExceptionTest() {
1608         mockUpQuery = new MockUp<Query>() {
1609
1610             @Mock
1611             public Object uniqueResult() {
1612                 throw new HibernateException("hibernate exception");
1613             }
1614         };
1615
1616         mockedSession = new MockUp<Session>() {
1617             @Mock
1618             public Query createQuery(String hql) {
1619                 return mockUpQuery.getMockInstance();
1620             }
1621         };
1622
1623         mockCd = new MockUp<CatalogDatabase>() {
1624             @Mock
1625             private Session getSession() {
1626                 return mockedSession.getMockInstance();
1627             }
1628         };
1629         thrown.expect(HibernateException.class);
1630         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1631
1632
1633     }
1634
1635     @Test
1636     public void getVnfResourceExceptionTest() {
1637         mockUpQuery = new MockUp<Query>() {
1638
1639             @Mock
1640             public Object uniqueResult() throws Exception {
1641                 throw new Exception();
1642             }
1643         };
1644
1645         mockedSession = new MockUp<Session>() {
1646             @Mock
1647             public Query createQuery(String hql) {
1648                 return mockUpQuery.getMockInstance();
1649             }
1650         };
1651
1652         mockCd = new MockUp<CatalogDatabase>() {
1653             @Mock
1654             private Session getSession() {
1655                 return mockedSession.getMockInstance();
1656             }
1657         };
1658         thrown.expect(Exception.class);
1659         VnfResource vnfResource = cd.getVnfResource("vnf","3992");
1660
1661
1662     }
1663
1664     @Test
1665     public void getVnfResourceByModelCustomizationIdTest() {
1666         mockUpQuery = new MockUp<Query>() {
1667
1668             @Mock
1669             public Object uniqueResult() throws Exception {
1670                 VnfResource vnfResource = new VnfResource();
1671                 vnfResource.setModelUuid("123-uuid");
1672                 return vnfResource;
1673             }
1674         };
1675
1676         mockedSession = new MockUp<Session>() {
1677             @Mock
1678             public Query createQuery(String hql) {
1679                 return mockUpQuery.getMockInstance();
1680             }
1681         };
1682
1683         mockCd = new MockUp<CatalogDatabase>() {
1684             @Mock
1685             private Session getSession() {
1686                 return mockedSession.getMockInstance();
1687             }
1688         };
1689
1690         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1691         assertEquals("123-uuid",vnfResource.getModelUuid());
1692
1693
1694     }
1695
1696     @Test
1697     public void getVnfResourceByModelCustomizationIdNullTest() {
1698         mockUpQuery = new MockUp<Query>() {
1699             @Mock
1700             public Object uniqueResult() throws Exception {
1701                 return null;
1702             }
1703         };
1704
1705         mockedSession = new MockUp<Session>() {
1706             @Mock
1707             public Query createQuery(String hql) {
1708                 return mockUpQuery.getMockInstance();
1709             }
1710         };
1711
1712         mockCd = new MockUp<CatalogDatabase>() {
1713             @Mock
1714             private Session getSession() {
1715                 return mockedSession.getMockInstance();
1716             }
1717         };
1718
1719         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1720         assertNull(vnfResource);
1721     }
1722
1723     @Test
1724     public void getVnfResourceByModelCustomizationIdNURExceptionTest() {
1725         mockUpQuery = new MockUp<Query>() {
1726
1727             @Mock
1728             public Object uniqueResult() throws Exception {
1729                 throw new NonUniqueResultException(-1);
1730             }
1731         };
1732
1733         mockedSession = new MockUp<Session>() {
1734             @Mock
1735             public Query createQuery(String hql) {
1736                 return mockUpQuery.getMockInstance();
1737             }
1738         };
1739
1740         mockCd = new MockUp<CatalogDatabase>() {
1741             @Mock
1742             private Session getSession() {
1743                 return mockedSession.getMockInstance();
1744             }
1745         };
1746         thrown.expect(NonUniqueResultException.class);
1747         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1748
1749
1750     }
1751
1752     @Test
1753     public void getVnfResourceByModelCustomizationIdHibernateExceptionTest() {
1754         mockUpQuery = new MockUp<Query>() {
1755
1756             @Mock
1757             public Object uniqueResult() throws Exception {
1758                 throw new HibernateException("hibernate exception");
1759             }
1760         };
1761
1762         mockedSession = new MockUp<Session>() {
1763             @Mock
1764             public Query createQuery(String hql) {
1765                 return mockUpQuery.getMockInstance();
1766             }
1767         };
1768
1769         mockCd = new MockUp<CatalogDatabase>() {
1770             @Mock
1771             private Session getSession() {
1772                 return mockedSession.getMockInstance();
1773             }
1774         };
1775         thrown.expect(HibernateException.class);
1776         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1777     }
1778
1779     @Test
1780     public void getVnfResourceByModelCustomizationIdExceptionTest() {
1781         mockUpQuery = new MockUp<Query>() {
1782
1783             @Mock
1784             public Object uniqueResult() throws Exception {
1785                 throw new NullPointerException();
1786             }
1787         };
1788
1789         mockedSession = new MockUp<Session>() {
1790             @Mock
1791             public Query createQuery(String hql) {
1792                 return mockUpQuery.getMockInstance();
1793             }
1794         };
1795
1796         mockCd = new MockUp<CatalogDatabase>() {
1797             @Mock
1798             private Session getSession() {
1799                 return mockedSession.getMockInstance();
1800             }
1801         };
1802         thrown.expect(NullPointerException.class);
1803         VnfResource vnfResource = cd.getVnfResourceByModelCustomizationId("3992");
1804     }
1805
1806
1807     @Test
1808     public void getServiceRecipeTest2() throws Exception{
1809         mockUpQuery = new MockUp<Query>() {
1810             @Mock
1811             public List <ServiceRecipe> list() throws Exception {
1812                 ServiceRecipe serviceRecipe = new ServiceRecipe();
1813                 serviceRecipe.setServiceModelUUID("123-uuid");
1814                 return Arrays.asList(serviceRecipe);
1815             }
1816         };
1817
1818         mockedSession = new MockUp<Session>() {
1819             @Mock
1820             public Query createQuery(String hql) {
1821                 return mockUpQuery.getMockInstance();
1822             }
1823         };
1824
1825         mockCd = new MockUp<CatalogDatabase>() {
1826             @Mock
1827             private Session getSession() {
1828                 return mockedSession.getMockInstance();
1829             }
1830         };
1831
1832         ServiceRecipe ht = cd.getServiceRecipe(1001,"3992");
1833         assertEquals("123-uuid", ht.getServiceModelUUID());
1834
1835         ht = cd.getServiceRecipe(1001, null);
1836         assertEquals("123-uuid", ht.getServiceModelUUID());
1837
1838     }
1839
1840     @Test
1841     public void getServiceRecipeTest2Exception() throws Exception{
1842         thrown.expect(Exception.class);
1843         ServiceRecipe ht = cd.getServiceRecipe(1001,"3992");
1844     }
1845
1846     @Test
1847     public void getVnfResourceCustomizationByModelCustomizationNameTest(){
1848         mockUpQuery = new MockUp<Query>() {
1849             @Mock
1850             public List<VnfResourceCustomization> list() throws Exception {
1851                 VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
1852                 vnfResourceCustomization.setVnfResourceModelUUID("123-uuid");
1853                 return Arrays.asList(vnfResourceCustomization);
1854             }
1855         };
1856
1857         mockedSession = new MockUp<Session>() {
1858             @Mock
1859             public Query createQuery(String hql) {
1860                 return mockUpQuery.getMockInstance();
1861             }
1862         };
1863
1864         mockCd = new MockUp<CatalogDatabase>() {
1865             @Mock
1866             private Session getSession() {
1867                 return mockedSession.getMockInstance();
1868             }
1869         };
1870         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelCustomizationName("test", "test234");
1871         assertEquals("123-uuid", vnf.getVnfResourceModelUUID());
1872
1873
1874     }
1875
1876     @Test
1877     public void getVnfResourceCustomizationByModelCustomizationNameEmptyTest(){
1878         mockUpQuery = new MockUp<Query>() {
1879             @Mock
1880             public List<VnfResourceCustomization> list() throws Exception {
1881                 return Arrays.asList();
1882             }
1883         };
1884
1885         mockedSession = new MockUp<Session>() {
1886             @Mock
1887             public Query createQuery(String hql) {
1888                 return mockUpQuery.getMockInstance();
1889             }
1890         };
1891
1892         mockCd = new MockUp<CatalogDatabase>() {
1893             @Mock
1894             private Session getSession() {
1895                 return mockedSession.getMockInstance();
1896             }
1897         };
1898         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelCustomizationName("test", "test234");
1899         assertEquals(null, vnf);
1900
1901
1902     }
1903
1904     @Test
1905     public void getVnfResourceByModelInvariantIdTest(){
1906         mockUpQuery = new MockUp<Query>() {
1907
1908             @Mock
1909             public Object uniqueResult(){
1910                 VnfResource vnfResource = new VnfResource();
1911                 vnfResource.setModelUuid("123-uuid");
1912                 return vnfResource;
1913             }
1914         };
1915
1916         mockedSession = new MockUp<Session>() {
1917             @Mock
1918             public Query createQuery(String hql) {
1919                 return mockUpQuery.getMockInstance();
1920             }
1921         };
1922
1923         mockCd = new MockUp<CatalogDatabase>() {
1924             @Mock
1925             private Session getSession() {
1926                 return mockedSession.getMockInstance();
1927             }
1928         };
1929         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1930         assertEquals("123-uuid", vnf.getModelUuid());
1931
1932
1933     }
1934
1935     @Test
1936     public void getVnfResourceByModelInvariantIdNURExceptionTest(){
1937         mockUpQuery = new MockUp<Query>() {
1938
1939             @Mock
1940             public Object uniqueResult(){
1941                 throw new NonUniqueResultException(-1);
1942             }
1943         };
1944
1945         mockedSession = new MockUp<Session>() {
1946             @Mock
1947             public Query createQuery(String hql) {
1948                 return mockUpQuery.getMockInstance();
1949             }
1950         };
1951
1952         mockCd = new MockUp<CatalogDatabase>() {
1953             @Mock
1954             private Session getSession() {
1955                 return mockedSession.getMockInstance();
1956             }
1957         };
1958         thrown.expect(NonUniqueResultException.class);
1959         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1960
1961
1962     }
1963
1964     @Test
1965     public void getVnfResourceByModelInvariantIdHibernateExceptionTest(){
1966         mockUpQuery = new MockUp<Query>() {
1967
1968             @Mock
1969             public Object uniqueResult(){
1970                 throw new HibernateException("hibernate exception");
1971             }
1972         };
1973
1974         mockedSession = new MockUp<Session>() {
1975             @Mock
1976             public Query createQuery(String hql) {
1977                 return mockUpQuery.getMockInstance();
1978             }
1979         };
1980
1981         mockCd = new MockUp<CatalogDatabase>() {
1982             @Mock
1983             private Session getSession() {
1984                 return mockedSession.getMockInstance();
1985             }
1986         };
1987         thrown.expect(HibernateException.class);
1988         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
1989
1990
1991     }
1992
1993     @Test
1994     public void getVnfResourceByModelInvariantIdExceptionTest(){
1995         mockUpQuery = new MockUp<Query>() {
1996
1997             @Mock
1998             public Object uniqueResult() throws Exception {
1999                 throw new Exception();
2000             }
2001         };
2002
2003         mockedSession = new MockUp<Session>() {
2004             @Mock
2005             public Query createQuery(String hql) {
2006                 return mockUpQuery.getMockInstance();
2007             }
2008         };
2009
2010         mockCd = new MockUp<CatalogDatabase>() {
2011             @Mock
2012             private Session getSession() {
2013                 return mockedSession.getMockInstance();
2014             }
2015         };
2016         thrown.expect(Exception.class);
2017         VnfResource vnf = cd.getVnfResourceByModelInvariantId("test", "test234");
2018
2019
2020     }
2021
2022     @Test
2023     public void getVnfResourceByIdTestException(){
2024         mockUpQuery = new MockUp<Query>() {
2025                 int id = 0;
2026                 @Mock
2027                 public Query setParameter(String name, Object val) {
2028                         id = (Integer)val;
2029                         return this.getMockInstance();
2030                 }
2031
2032             @Mock
2033             public List<VnfResource> list() throws Exception {
2034                 if (id==0) return new ArrayList<VnfResource>();
2035                 VnfResource vm = new VnfResource();
2036                 vm.setModelInvariantUuid(Integer.toString(id));
2037                 return Arrays.asList(vm);
2038             }
2039         };
2040
2041         mockedSession = new MockUp<Session>() {
2042             @Mock
2043             public Query createQuery(String hql) {
2044                 return mockUpQuery.getMockInstance();
2045             }
2046         };
2047
2048         mockCd = new MockUp<CatalogDatabase>() {
2049             @Mock
2050             private Session getSession() {
2051                 return mockedSession.getMockInstance();
2052             }
2053         };
2054
2055         VnfResource vnf = cd.getVnfResourceById(19299);
2056         assertEquals("19299", vnf.getModelInvariantUuid());
2057
2058                 vnf = cd.getVnfResourceById(0);
2059                 assertNull(vnf);
2060     }
2061
2062     @Test
2063     public void getVfModuleModelName(){
2064         mockUpQuery = new MockUp<Query>() {
2065             @Mock
2066             public List<VfModule> list() throws Exception {
2067                 VfModule vfModule = new VfModule();
2068                 vfModule.setModelUUID("123-uuid");
2069                 return Arrays.asList(vfModule);
2070             }
2071         };
2072
2073         mockedSession = new MockUp<Session>() {
2074             @Mock
2075             public Query createQuery(String hql) {
2076                 return mockUpQuery.getMockInstance();
2077             }
2078         };
2079
2080         mockCd = new MockUp<CatalogDatabase>() {
2081             @Mock
2082             private Session getSession() {
2083                 return mockedSession.getMockInstance();
2084             }
2085         };
2086         VfModule vfModule = cd.getVfModuleModelName("vfmodule");
2087         assertEquals("123-uuid", vfModule.getModelUUID());
2088
2089
2090     }
2091
2092     @Test
2093     public void getVfModuleModelNameExceptionTest(){
2094         mockUpQuery = new MockUp<Query>() {
2095             @Mock
2096             public List<VfModule> list() throws Exception {
2097                 return Arrays.asList();
2098             }
2099         };
2100
2101         mockedSession = new MockUp<Session>() {
2102             @Mock
2103             public Query createQuery(String hql) {
2104                 return mockUpQuery.getMockInstance();
2105             }
2106         };
2107
2108         mockCd = new MockUp<CatalogDatabase>() {
2109             @Mock
2110             private Session getSession() {
2111                 return mockedSession.getMockInstance();
2112             }
2113         };
2114         VfModule vfModule = cd.getVfModuleModelName("vfmodule");
2115         assertEquals(null, vfModule);
2116
2117
2118     }
2119
2120     @Test
2121     public void getVfModuleModelNameTest() {
2122         mockUpQuery = new MockUp<Query>() {
2123                 String modelVersion = null;
2124
2125                 @Mock
2126                 public Query setParameter(String name, Object val) {
2127                         if (name.equals("model_version")) modelVersion = (String)val;
2128                         return this.getMockInstance();
2129                 }
2130
2131             @Mock
2132             public Object uniqueResult() {
2133                 if (modelVersion==null || modelVersion.equals("nil")) {
2134                         return null;
2135                 }
2136                 VfModule vfModule = new VfModule();
2137                 vfModule.setModelUUID("123-uuid");
2138                 return vfModule;
2139             }
2140         };
2141
2142         mockedSession = new MockUp<Session>() {
2143             @Mock
2144             public Query createQuery(String hql) {
2145                 return mockUpQuery.getMockInstance();
2146             }
2147         };
2148
2149         mockCd = new MockUp<CatalogDatabase>() {
2150             @Mock
2151             private Session getSession() {
2152                 return mockedSession.getMockInstance();
2153             }
2154         };
2155
2156         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
2157         assertEquals("123-uuid", vfModule.getModelUUID());
2158
2159         vfModule = cd.getVfModuleModelName("tetes","nil");
2160         assertNull(vfModule);
2161     }
2162
2163     @Test
2164     public void getVfModuleModelNameNURExceptionTest() {
2165         mockUpQuery = new MockUp<Query>() {
2166
2167             @Mock
2168             public Object uniqueResult() {
2169                 throw new NonUniqueResultException(-1);
2170             }
2171         };
2172
2173         mockedSession = new MockUp<Session>() {
2174             @Mock
2175             public Query createQuery(String hql) {
2176                 return mockUpQuery.getMockInstance();
2177             }
2178         };
2179
2180         mockCd = new MockUp<CatalogDatabase>() {
2181             @Mock
2182             private Session getSession() {
2183                 return mockedSession.getMockInstance();
2184             }
2185         };
2186         thrown.expect(NonUniqueResultException.class);
2187         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
2188
2189
2190     }
2191
2192     @Test
2193     public void getVfModuleModelNameHibernateExceptionTest() {
2194         mockUpQuery = new MockUp<Query>() {
2195
2196             @Mock
2197             public Object uniqueResult() {
2198                 throw new HibernateException("hibernate exception");
2199             }
2200         };
2201
2202         mockedSession = new MockUp<Session>() {
2203             @Mock
2204             public Query createQuery(String hql) {
2205                 return mockUpQuery.getMockInstance();
2206             }
2207         };
2208
2209         mockCd = new MockUp<CatalogDatabase>() {
2210             @Mock
2211             private Session getSession() {
2212                 return mockedSession.getMockInstance();
2213             }
2214         };
2215         thrown.expect(HibernateException.class);
2216         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
2217
2218
2219     }
2220
2221     @Test
2222     public void getVfModuleModelNameGenericExceptionTest() {
2223         mockUpQuery = new MockUp<Query>() {
2224
2225             @Mock
2226             public Object uniqueResult() throws Exception {
2227                 throw new Exception();
2228             }
2229         };
2230
2231         mockedSession = new MockUp<Session>() {
2232             @Mock
2233             public Query createQuery(String hql) {
2234                 return mockUpQuery.getMockInstance();
2235             }
2236         };
2237
2238         mockCd = new MockUp<CatalogDatabase>() {
2239             @Mock
2240             private Session getSession() {
2241                 return mockedSession.getMockInstance();
2242             }
2243         };
2244         thrown.expect(Exception.class);
2245         VfModule vfModule = cd.getVfModuleModelName("tetes","4kidsl");
2246
2247
2248     }
2249
2250     @Test
2251     public void ggetVfModuleCustomizationByModelNameTest(){
2252         mockUpQuery = new MockUp<Query>() {
2253             @Mock
2254             public List<VfModuleCustomization> list() throws Exception {
2255                 VfModuleCustomization vfModuleCustomization = new VfModuleCustomization();
2256                 vfModuleCustomization.setVfModuleModelUuid("123-uuid");
2257                 return Arrays.asList(vfModuleCustomization);
2258             }
2259         };
2260
2261         mockedSession = new MockUp<Session>() {
2262             @Mock
2263             public Query createQuery(String hql) {
2264                 return mockUpQuery.getMockInstance();
2265             }
2266         };
2267
2268         mockCd = new MockUp<CatalogDatabase>() {
2269             @Mock
2270             private Session getSession() {
2271                 return mockedSession.getMockInstance();
2272             }
2273         };
2274         VfModuleCustomization vfModuleCustomization = cd.getVfModuleCustomizationByModelName("tetes");
2275         assertEquals("123-uuid", vfModuleCustomization.getVfModuleModelUuid());
2276
2277
2278     }
2279
2280     @Test
2281     public void ggetVfModuleCustomizationByModelNameEmptyTest(){
2282         mockUpQuery = new MockUp<Query>() {
2283             @Mock
2284             public List<VfModuleCustomization> list() throws Exception {
2285                 return Arrays.asList();
2286             }
2287         };
2288
2289         mockedSession = new MockUp<Session>() {
2290             @Mock
2291             public Query createQuery(String hql) {
2292                 return mockUpQuery.getMockInstance();
2293             }
2294         };
2295
2296         mockCd = new MockUp<CatalogDatabase>() {
2297             @Mock
2298             private Session getSession() {
2299                 return mockedSession.getMockInstance();
2300             }
2301         };
2302         VfModuleCustomization vfModuleCustomization = cd.getVfModuleCustomizationByModelName("tetes");
2303         assertEquals(null, vfModuleCustomization);
2304
2305
2306     }
2307
2308     @Test
2309     public void getNetworkResourceTest(){
2310         mockUpQuery = new MockUp<Query>() {
2311             @Mock
2312             public List<NetworkResource> list() throws Exception {
2313                 NetworkResource networkResource = new NetworkResource();
2314                 networkResource.setModelUUID("123-uuid");
2315                 return Arrays.asList(networkResource);
2316             }
2317         };
2318
2319         mockedSession = new MockUp<Session>() {
2320             @Mock
2321             public Query createQuery(String hql) {
2322                 return mockUpQuery.getMockInstance();
2323             }
2324         };
2325
2326         mockCd = new MockUp<CatalogDatabase>() {
2327             @Mock
2328             private Session getSession() {
2329                 return mockedSession.getMockInstance();
2330             }
2331         };
2332         NetworkResource networkResource = cd.getNetworkResource("tetes");
2333         assertEquals("123-uuid", networkResource.getModelUUID());
2334
2335
2336     }
2337
2338     @Test
2339     public void getNetworkResourceTestEmptyException(){
2340         mockUpQuery = new MockUp<Query>() {
2341             @Mock
2342             public List<NetworkResource> list() throws Exception {
2343                 return Arrays.asList();
2344             }
2345         };
2346
2347         mockedSession = new MockUp<Session>() {
2348             @Mock
2349             public Query createQuery(String hql) {
2350                 return mockUpQuery.getMockInstance();
2351             }
2352         };
2353
2354         mockCd = new MockUp<CatalogDatabase>() {
2355             @Mock
2356             private Session getSession() {
2357                 return mockedSession.getMockInstance();
2358             }
2359         };
2360         NetworkResource networkResource = cd.getNetworkResource("tetes");
2361         assertEquals(null, networkResource);
2362
2363
2364     }
2365
2366     @Test
2367     public void getVnfRecipeTest(){
2368
2369         mockUpQuery = new MockUp<Query>() {
2370             @Mock
2371             public List<VnfRecipe> list() throws Exception {
2372                 VnfRecipe vnfRecipe = new VnfRecipe();
2373                 vnfRecipe.setVfModuleId("123-id");
2374                 return Arrays.asList(vnfRecipe);
2375             }
2376         };
2377
2378         mockedSession = new MockUp<Session>() {
2379             @Mock
2380             public Query createQuery(String hql) {
2381                 return mockUpQuery.getMockInstance();
2382             }
2383         };
2384
2385         mockCd = new MockUp<CatalogDatabase>() {
2386             @Mock
2387             private Session getSession() {
2388                 return mockedSession.getMockInstance();
2389             }
2390         };
2391
2392         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","ergfedrf","4993493");
2393         assertEquals("123-id", vnfRecipe.getVfModuleId());
2394
2395
2396     }
2397
2398     @Test
2399     public void getVnfRecipeEmptyTest(){
2400
2401         mockUpQuery = new MockUp<Query>() {
2402             @Mock
2403             public List<VnfRecipe> list() throws Exception {
2404                 return Collections.emptyList();
2405             }
2406         };
2407
2408         mockedSession = new MockUp<Session>() {
2409             @Mock
2410             public Query createQuery(String hql) {
2411                 return mockUpQuery.getMockInstance();
2412             }
2413         };
2414
2415         mockCd = new MockUp<CatalogDatabase>() {
2416             @Mock
2417             private Session getSession() {
2418                 return mockedSession.getMockInstance();
2419             }
2420         };
2421
2422         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","ergfedrf","4993493");
2423         assertEquals(null, vnfRecipe);
2424
2425
2426     }
2427
2428     @Test
2429     public void getVnfRecipe2Test(){
2430         mockUpQuery = new MockUp<Query>() {
2431             @Mock
2432             public List<VnfRecipe> list() throws Exception {
2433                 VnfRecipe vnfRecipe = new VnfRecipe();
2434                 vnfRecipe.setId(1);
2435                 return Arrays.asList(vnfRecipe);
2436             }
2437         };
2438
2439         mockedSession = new MockUp<Session>() {
2440             @Mock
2441             public Query createQuery(String hql) {
2442                 return mockUpQuery.getMockInstance();
2443             }
2444         };
2445
2446         mockCd = new MockUp<CatalogDatabase>() {
2447             @Mock
2448             private Session getSession() {
2449                 return mockedSession.getMockInstance();
2450             }
2451         };
2452         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","4993493");
2453         assertEquals(1, vnfRecipe.getId());
2454
2455
2456     }
2457
2458     @Test
2459     public void getVnfRecipe2EmptyTest(){
2460         mockUpQuery = new MockUp<Query>() {
2461             @Mock
2462             public List<VnfRecipe> list() throws Exception {
2463                 return Collections.emptyList();
2464             }
2465         };
2466
2467         mockedSession = new MockUp<Session>() {
2468             @Mock
2469             public Query createQuery(String hql) {
2470                 return mockUpQuery.getMockInstance();
2471             }
2472         };
2473
2474         mockCd = new MockUp<CatalogDatabase>() {
2475             @Mock
2476             private Session getSession() {
2477                 return mockedSession.getMockInstance();
2478             }
2479         };
2480         VnfRecipe vnfRecipe = cd.getVnfRecipe("tetes","4993493");
2481         assertEquals(null, vnfRecipe);
2482
2483
2484     }
2485
2486     @Test
2487     public void getVnfRecipeByVfModuleIdTest(){
2488         mockUpQuery = new MockUp<Query>() {
2489             @Mock
2490             public List<VnfRecipe> list() throws Exception {
2491                 VnfRecipe vnfRecipe = new VnfRecipe();
2492                 vnfRecipe.setId(1);
2493                 return Arrays.asList(vnfRecipe);
2494             }
2495         };
2496
2497         mockedSession = new MockUp<Session>() {
2498             @Mock
2499             public Query createQuery(String hql) {
2500                 return mockUpQuery.getMockInstance();
2501             }
2502         };
2503
2504         mockCd = new MockUp<CatalogDatabase>() {
2505             @Mock
2506             private Session getSession() {
2507                 return mockedSession.getMockInstance();
2508             }
2509         };
2510
2511         VnfRecipe vnfRecipe = cd.getVnfRecipeByVfModuleId("tetes","4993493","vnf");
2512         assertEquals(1, vnfRecipe.getId());
2513
2514
2515     }
2516
2517     @Test
2518     public void getVnfRecipeByVfModuleIdEmptyTest(){
2519         mockUpQuery = new MockUp<Query>() {
2520             @Mock
2521             public List<VnfRecipe> list() throws Exception {
2522                 return Collections.emptyList();
2523             }
2524         };
2525
2526         mockedSession = new MockUp<Session>() {
2527             @Mock
2528             public Query createQuery(String hql) {
2529                 return mockUpQuery.getMockInstance();
2530             }
2531         };
2532
2533         mockCd = new MockUp<CatalogDatabase>() {
2534             @Mock
2535             private Session getSession() {
2536                 return mockedSession.getMockInstance();
2537             }
2538         };
2539
2540         VnfRecipe vnfRecipe = cd.getVnfRecipeByVfModuleId("tetes","4993493","vnf");
2541         assertEquals(null, vnfRecipe);
2542
2543
2544     }
2545
2546     @Test
2547     public void getVfModuleTypeTestException(){
2548         mockUpQuery = new MockUp<Query>() {
2549                 String type = null;
2550                 @Mock
2551                 public Query setParameter(String name, Object val) {
2552                         type = (String)val;
2553                         return this.getMockInstance();
2554                 }
2555
2556                 @Mock
2557             public List<VfModule> list() {
2558                         if ("nil".equals(type)) return new ArrayList<VfModule>();
2559
2560                         VfModule vm = new VfModule();
2561                         vm.setModelUUID("123-uuid");
2562                 return Arrays.asList(vm);
2563             }
2564         };
2565
2566         mockedSession = new MockUp<Session>() {
2567             @Mock
2568             public Query createQuery(String hql) {
2569                 return mockUpQuery.getMockInstance();
2570             }
2571         };
2572
2573         mockCd = new MockUp<CatalogDatabase>() {
2574             @Mock
2575             private Session getSession() {
2576                 return mockedSession.getMockInstance();
2577             }
2578         };
2579
2580         VfModule vnf = cd.getVfModuleType("4993493");
2581         assertEquals("123-uuid", vnf.getModelUUID());
2582
2583         vnf = cd.getVfModuleType("nil");
2584         assertNull(vnf);
2585     }
2586
2587     @Test
2588     public void getVnfResourceByServiceUuidTest(){
2589         mockUpQuery = new MockUp<Query>() {
2590
2591             @Mock
2592             public Object uniqueResult() {
2593                 VnfResource vnfResource = new VnfResource();
2594                 vnfResource.setModelUuid("123-uuid");
2595                 return vnfResource;
2596             }
2597         };
2598
2599         mockedSession = new MockUp<Session>() {
2600             @Mock
2601             public Query createQuery(String hql) {
2602                 return mockUpQuery.getMockInstance();
2603             }
2604         };
2605
2606         mockCd = new MockUp<CatalogDatabase>() {
2607             @Mock
2608             private Session getSession() {
2609                 return mockedSession.getMockInstance();
2610             }
2611         };
2612         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
2613         assertEquals("123-uuid", vnfResource.getModelUuid());
2614
2615
2616     }
2617
2618     @Test
2619     public void getVnfResourceByServiceUuidNURExceptionTest(){
2620         mockUpQuery = new MockUp<Query>() {
2621
2622             @Mock
2623             public Object uniqueResult() {
2624                 throw new NonUniqueResultException(-1);
2625             }
2626         };
2627
2628         mockedSession = new MockUp<Session>() {
2629             @Mock
2630             public Query createQuery(String hql) {
2631                 return mockUpQuery.getMockInstance();
2632             }
2633         };
2634
2635         mockCd = new MockUp<CatalogDatabase>() {
2636             @Mock
2637             private Session getSession() {
2638                 return mockedSession.getMockInstance();
2639             }
2640         };
2641         thrown.expect(NonUniqueResultException.class);
2642         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
2643
2644
2645     }
2646
2647     @Test
2648     public void getVnfResourceByServiceUuidHibernateExceptionTest(){
2649         mockUpQuery = new MockUp<Query>() {
2650
2651             @Mock
2652             public Object uniqueResult() {
2653                 throw new HibernateException("hibernate exception");
2654             }
2655         };
2656
2657         mockedSession = new MockUp<Session>() {
2658             @Mock
2659             public Query createQuery(String hql) {
2660                 return mockUpQuery.getMockInstance();
2661             }
2662         };
2663
2664         mockCd = new MockUp<CatalogDatabase>() {
2665             @Mock
2666             private Session getSession() {
2667                 return mockedSession.getMockInstance();
2668             }
2669         };
2670         thrown.expect(HibernateException.class);
2671         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
2672
2673
2674     }
2675
2676     @Test
2677     public void getVnfResourceByServiceUuidExceptionTest(){
2678         mockUpQuery = new MockUp<Query>() {
2679
2680             @Mock
2681             public Object uniqueResult() throws Exception {
2682                 throw new Exception();
2683             }
2684         };
2685
2686         mockedSession = new MockUp<Session>() {
2687             @Mock
2688             public Query createQuery(String hql) {
2689                 return mockUpQuery.getMockInstance();
2690             }
2691         };
2692
2693         mockCd = new MockUp<CatalogDatabase>() {
2694             @Mock
2695             private Session getSession() {
2696                 return mockedSession.getMockInstance();
2697             }
2698         };
2699         thrown.expect(Exception.class);
2700         VnfResource vnfResource = cd.getVnfResourceByServiceUuid("4993493");
2701
2702
2703     }
2704
2705     @Test
2706     public void getVnfResourceByVnfUuidTest(){
2707         mockUpQuery = new MockUp<Query>() {
2708
2709             @Mock
2710             public Object uniqueResult() {
2711                 VnfResource vnfResource = new VnfResource();
2712                 vnfResource.setModelUuid("123-uuid");
2713                 return vnfResource;
2714             }
2715         };
2716
2717         mockedSession = new MockUp<Session>() {
2718             @Mock
2719             public Query createQuery(String hql) {
2720                 return mockUpQuery.getMockInstance();
2721             }
2722         };
2723
2724         mockCd = new MockUp<CatalogDatabase>() {
2725             @Mock
2726             private Session getSession() {
2727                 return mockedSession.getMockInstance();
2728             }
2729         };
2730
2731         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2732         assertEquals("123-uuid", vnfResource.getModelUuid());
2733
2734
2735     }
2736
2737     @Test
2738     public void getVnfResourceByVnfUuidNURExceptionTest(){
2739         mockUpQuery = new MockUp<Query>() {
2740
2741             @Mock
2742             public Object uniqueResult() {
2743                 throw new NonUniqueResultException(-1);
2744             }
2745         };
2746
2747         mockedSession = new MockUp<Session>() {
2748             @Mock
2749             public Query createQuery(String hql) {
2750                 return mockUpQuery.getMockInstance();
2751             }
2752         };
2753
2754         mockCd = new MockUp<CatalogDatabase>() {
2755             @Mock
2756             private Session getSession() {
2757                 return mockedSession.getMockInstance();
2758             }
2759         };
2760         thrown.expect(NonUniqueResultException.class);
2761         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2762
2763
2764     }
2765
2766     @Test
2767     public void getVnfResourceByVnfUuidHibernateExceptionTest(){
2768         mockUpQuery = new MockUp<Query>() {
2769
2770             @Mock
2771             public Object uniqueResult() {
2772                 throw new HibernateException("hibernate exception");
2773             }
2774         };
2775
2776         mockedSession = new MockUp<Session>() {
2777             @Mock
2778             public Query createQuery(String hql) {
2779                 return mockUpQuery.getMockInstance();
2780             }
2781         };
2782
2783         mockCd = new MockUp<CatalogDatabase>() {
2784             @Mock
2785             private Session getSession() {
2786                 return mockedSession.getMockInstance();
2787             }
2788         };
2789         thrown.expect(HibernateException.class);
2790         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2791
2792
2793     }
2794
2795     @Test
2796     public void getVnfResourceByVnfUuidExceptionTest(){
2797         mockUpQuery = new MockUp<Query>() {
2798
2799             @Mock
2800             public Object uniqueResult() throws Exception {
2801                 throw new Exception();
2802             }
2803         };
2804
2805         mockedSession = new MockUp<Session>() {
2806             @Mock
2807             public Query createQuery(String hql) {
2808                 return mockUpQuery.getMockInstance();
2809             }
2810         };
2811
2812         mockCd = new MockUp<CatalogDatabase>() {
2813             @Mock
2814             private Session getSession() {
2815                 return mockedSession.getMockInstance();
2816             }
2817         };
2818         thrown.expect(Exception.class);
2819         VnfResource vnfResource = cd.getVnfResourceByVnfUuid("4993493");
2820
2821
2822     }
2823
2824     @Test
2825     public void getVfModuleByModelInvariantUuidTest(){
2826
2827         mockUpQuery = new MockUp<Query>() {
2828
2829             @Mock
2830             public List<VfModule> list() throws Exception {
2831                 VfModule vfModule = new VfModule();
2832                 vfModule.setModelUUID("123-uuid");
2833                 return Arrays.asList(vfModule);
2834             }
2835         };
2836
2837         mockedSession = new MockUp<Session>() {
2838             @Mock
2839             public Query createQuery(String hql) {
2840                 return mockUpQuery.getMockInstance();
2841             }
2842         };
2843
2844         mockCd = new MockUp<CatalogDatabase>() {
2845             @Mock
2846             private Session getSession() {
2847                 return mockedSession.getMockInstance();
2848             }
2849         };
2850
2851         VfModule vfModule = cd.getVfModuleByModelInvariantUuid("4993493");
2852         assertEquals("123-uuid", vfModule.getModelUUID());
2853
2854
2855     }
2856
2857     @Test
2858     public void getVfModuleByModelInvariantUuidEmptyTest(){
2859
2860         mockUpQuery = new MockUp<Query>() {
2861
2862             @Mock
2863             public List<VfModule> list() throws Exception {
2864                 return Collections.emptyList();
2865             }
2866         };
2867
2868         mockedSession = new MockUp<Session>() {
2869             @Mock
2870             public Query createQuery(String hql) {
2871                 return mockUpQuery.getMockInstance();
2872             }
2873         };
2874
2875         mockCd = new MockUp<CatalogDatabase>() {
2876             @Mock
2877             private Session getSession() {
2878                 return mockedSession.getMockInstance();
2879             }
2880         };
2881
2882         VfModule vfModule = cd.getVfModuleByModelInvariantUuid("4993493");
2883         assertEquals(null, vfModule);
2884
2885
2886     }
2887
2888     @Test
2889     public void getVfModuleByModelCustomizationUuidTest(){
2890         mockUpQuery = new MockUp<Query>() {
2891             @Mock
2892             public Object uniqueResult() {
2893                 VfModuleCustomization vc = new VfModuleCustomization();
2894                 vc.setModelCustomizationUuid("4993493");
2895                 return vc;
2896             }
2897         };
2898
2899         mockedSession = new MockUp<Session>() {
2900             @Mock
2901             public Query createQuery(String hql) {
2902                 return mockUpQuery.getMockInstance();
2903             }
2904         };
2905
2906         mockCd = new MockUp<CatalogDatabase>() {
2907             @Mock
2908             private Session getSession() {
2909                 return mockedSession.getMockInstance();
2910             }
2911         };
2912
2913         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
2914         assertEquals("4993493", vnf.getModelCustomizationUuid());
2915     }
2916
2917     @Test
2918     public void getVfModuleByModelCustomizationUuidNullTest(){
2919         mockUpQuery = new MockUp<Query>() {
2920             @Mock
2921             public Object uniqueResult() {
2922                 return null;
2923             }
2924         };
2925
2926         mockedSession = new MockUp<Session>() {
2927             @Mock
2928             public Query createQuery(String hql) {
2929                 return mockUpQuery.getMockInstance();
2930             }
2931         };
2932
2933         mockCd = new MockUp<CatalogDatabase>() {
2934             @Mock
2935             private Session getSession() {
2936                 return mockedSession.getMockInstance();
2937             }
2938         };
2939
2940         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
2941         assertNull(vnf);
2942     }
2943
2944     @Test
2945     public void getVfModuleByModelCustomizationUuidNonUniqueExceptionTest(){
2946         mockUpQuery = new MockUp<Query>() {
2947             @Mock
2948             public Object uniqueResult() {
2949                 throw new org.hibernate.NonUniqueResultException(2);
2950             }
2951         };
2952
2953         mockedSession = new MockUp<Session>() {
2954             @Mock
2955             public Query createQuery(String hql) {
2956                 return mockUpQuery.getMockInstance();
2957             }
2958         };
2959
2960         mockCd = new MockUp<CatalogDatabase>() {
2961             @Mock
2962             private Session getSession() {
2963                 return mockedSession.getMockInstance();
2964             }
2965         };
2966
2967         thrown.expect(org.hibernate.NonUniqueResultException.class);
2968         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
2969     }
2970
2971     @Test
2972     public void getVfModuleByModelCustomizationUuidHibernateExceptionTest(){
2973         mockUpQuery = new MockUp<Query>() {
2974             @Mock
2975             public Object uniqueResult() {
2976                 throw new org.hibernate.HibernateException("test case");
2977             }
2978         };
2979
2980         mockedSession = new MockUp<Session>() {
2981             @Mock
2982             public Query createQuery(String hql) {
2983                 return mockUpQuery.getMockInstance();
2984             }
2985         };
2986
2987         mockCd = new MockUp<CatalogDatabase>() {
2988             @Mock
2989             private Session getSession() {
2990                 return mockedSession.getMockInstance();
2991             }
2992         };
2993
2994         thrown.expect(org.hibernate.HibernateException.class);
2995         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
2996     }
2997
2998     @Test
2999     public void getVfModuleByModelCustomizationUuidExceptionTest(){
3000         mockUpQuery = new MockUp<Query>() {
3001             @Mock
3002             public Object uniqueResult() {
3003                 throw new NullPointerException();
3004             }
3005         };
3006
3007         mockedSession = new MockUp<Session>() {
3008             @Mock
3009             public Query createQuery(String hql) {
3010                 return mockUpQuery.getMockInstance();
3011             }
3012         };
3013
3014         mockCd = new MockUp<CatalogDatabase>() {
3015             @Mock
3016             private Session getSession() {
3017                 return mockedSession.getMockInstance();
3018             }
3019         };
3020
3021         thrown.expect(NullPointerException.class);
3022         VfModuleCustomization vnf = cd.getVfModuleByModelCustomizationUuid("4993493");
3023     }
3024
3025     @Test
3026     public void getVfModuleCustomizationByModelCustomizationIdTest(){
3027         mockUpQuery = new MockUp<Query>() {
3028                 String modelCustomizationUuid = null;
3029
3030                 @Mock
3031                 public Query setParameter(String name, Object val) {
3032                         if (name.equals("modelCustomizationUuid")) modelCustomizationUuid = (String)val;
3033                         return this.getMockInstance();
3034                 }
3035
3036             @Mock
3037             public Object uniqueResult() {
3038                         if ("nil".equals(modelCustomizationUuid)) return null;
3039                         if ("multi".equals(modelCustomizationUuid)) throw new org.hibernate.NonUniqueResultException(2);
3040                         if ("he".equals(modelCustomizationUuid)) throw new org.hibernate.HibernateException("test case");
3041                         if ("npe".equals(modelCustomizationUuid)) throw new NullPointerException();
3042
3043                         VfModuleCustomization vm = new VfModuleCustomization();
3044                 vm.setModelCustomizationUuid("4993493");
3045                 return vm;
3046             }
3047         };
3048
3049         mockedSession = new MockUp<Session>() {
3050             @Mock
3051             public Query createQuery(String hql) {
3052                 return mockUpQuery.getMockInstance();
3053             }
3054         };
3055
3056         mockCd = new MockUp<CatalogDatabase>() {
3057             @Mock
3058             private Session getSession() {
3059                 return mockedSession.getMockInstance();
3060             }
3061         };
3062
3063         VfModuleCustomization vnf = cd.getVfModuleCustomizationByModelCustomizationId("4993493");
3064         assertEquals("4993493", vnf.getModelCustomizationUuid());
3065
3066         vnf = cd.getVfModuleCustomizationByModelCustomizationId("nil");
3067         assertNull(vnf);
3068
3069
3070         try {
3071                 thrown = ExpectedException.none();
3072                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3073                 vnf = cd.getVfModuleCustomizationByModelCustomizationId("multi");
3074         } catch (org.hibernate.NonUniqueResultException e) {
3075                 // noop
3076         }
3077
3078         try {
3079                 thrown = ExpectedException.none();
3080                 thrown.expect(org.hibernate.HibernateException.class);
3081                 vnf = cd.getVfModuleCustomizationByModelCustomizationId("he");
3082         } catch (org.hibernate.HibernateException e) {
3083                 // noop
3084         }
3085
3086         try {
3087                 thrown = ExpectedException.none();
3088                 thrown.expect(NullPointerException.class);
3089                 vnf = cd.getVfModuleCustomizationByModelCustomizationId("npe");
3090         } catch (NullPointerException e) {
3091                 // noop
3092         }
3093
3094     }
3095
3096     @Test
3097     public void getVfModuleByModelUuidTestException(){
3098         mockUpQuery = new MockUp<Query>() {
3099                 String modelUuidValue = null;
3100
3101                 @Mock
3102                 public Query setParameter(String name, Object val) {
3103                         if (name.equals("modelUuidValue")) modelUuidValue = (String)val;
3104                         return this.getMockInstance();
3105                 }
3106
3107                 @Mock
3108                 public List<VfModule> list() {
3109                         if ("nil".equals(modelUuidValue)) return null;
3110                         if ("multi".equals(modelUuidValue)) throw new org.hibernate.NonUniqueResultException(2);
3111                         if ("he".equals(modelUuidValue)) throw new org.hibernate.HibernateException("test case");
3112                         if ("npe".equals(modelUuidValue)) throw new NullPointerException();
3113
3114                         VfModule vfModule = new VfModule();
3115                         vfModule.setModelInvariantUuid(modelUuidValue);
3116                         return Arrays.asList(vfModule);
3117                 }
3118         };
3119
3120         mockedSession = new MockUp<Session>() {
3121                 @Mock
3122                 public Query createQuery(String hql) {
3123                         return mockUpQuery.getMockInstance();
3124                 }
3125         };
3126
3127         mockCd = new MockUp<CatalogDatabase>() {
3128                 @Mock
3129                 private Session getSession() {
3130                         return mockedSession.getMockInstance();
3131                 }
3132         };
3133
3134         VfModule vnf = cd.getVfModuleByModelUuid("4993493");
3135         assertEquals("4993493", vnf.getModelInvariantUuid());
3136
3137         vnf = cd.getVfModuleByModelUuid("nil");
3138         assertNull(vnf);
3139
3140         try {
3141                 thrown = ExpectedException.none();
3142                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3143                 vnf = cd.getVfModuleByModelUuid("multi");
3144         } catch (org.hibernate.NonUniqueResultException e) {
3145                 // noop
3146         }
3147
3148         try {
3149                 thrown = ExpectedException.none();
3150                 thrown.expect(org.hibernate.HibernateException.class);
3151                 vnf = cd.getVfModuleByModelUuid("he");
3152         } catch (org.hibernate.HibernateException e) {
3153                 // noop
3154         }
3155
3156         try {
3157                 thrown = ExpectedException.none();
3158                 thrown.expect(NullPointerException.class);
3159                 vnf = cd.getVfModuleByModelUuid("npe");
3160         } catch (NullPointerException e) {
3161                 // noop
3162         }
3163     }
3164
3165
3166     @Test
3167     public void getVnfResourceCustomizationByModelVersionIdTest(){
3168         mockUpQuery = new MockUp<Query>() {
3169                 String modelVersionId = null;
3170
3171                 @Mock
3172                 public Query setParameter(String name, Object val) {
3173                         if (name.equals("modelVersionId")) modelVersionId = (String)val;
3174                         return this.getMockInstance();
3175                 }
3176
3177                 @Mock
3178                 public Object uniqueResult() {
3179                         if ("nil".equals(modelVersionId)) return null;
3180                         if ("multi".equals(modelVersionId)) throw new org.hibernate.NonUniqueResultException(2);
3181                         if ("he".equals(modelVersionId)) throw new org.hibernate.HibernateException("test case");
3182                         if ("npe".equals(modelVersionId)) throw new NullPointerException();
3183
3184                         VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
3185                         vnfResourceCustomization.setVnfResourceModelUuid(modelVersionId);
3186                         return vnfResourceCustomization;
3187                 }
3188         };
3189
3190         mockedSession = new MockUp<Session>() {
3191                 @Mock
3192                 public Query createQuery(String hql) {
3193                         return mockUpQuery.getMockInstance();
3194                 }
3195         };
3196
3197         mockCd = new MockUp<CatalogDatabase>() {
3198                 @Mock
3199             public VnfResource getVnfResourceByModelUuid(String modelUuid) {
3200                         return new VnfResource();
3201                 }
3202
3203                 @Mock
3204             public ArrayList<VfModuleCustomization> getAllVfModuleCustomizations(String vnfResourceCustomizationMCU) {
3205                         ArrayList<VfModuleCustomization> toRet = new ArrayList<VfModuleCustomization>();
3206                         VfModuleCustomization vmc = new VfModuleCustomization();
3207                         toRet.add(vmc);
3208                         return toRet;
3209                 }
3210
3211                 @Mock
3212                 private Session getSession() {
3213                         return mockedSession.getMockInstance();
3214                 }
3215         };
3216
3217         VnfResourceCustomization vnf = cd.getVnfResourceCustomizationByModelVersionId("4993493");
3218         assertEquals("4993493", vnf.getVnfResourceModelUuid());
3219
3220         vnf = cd.getVnfResourceCustomizationByModelVersionId("nil");
3221         assertNull(vnf);
3222
3223         try {
3224                 thrown = ExpectedException.none();
3225                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3226                 vnf = cd.getVnfResourceCustomizationByModelVersionId("multi");
3227         } catch (org.hibernate.NonUniqueResultException e) {
3228                 // noop
3229         }
3230
3231         try {
3232                 thrown = ExpectedException.none();
3233                 thrown.expect(org.hibernate.HibernateException.class);
3234                 vnf = cd.getVnfResourceCustomizationByModelVersionId("he");
3235         } catch (org.hibernate.HibernateException e) {
3236                 // noop
3237         }
3238
3239         try {
3240                 thrown = ExpectedException.none();
3241                 thrown.expect(NullPointerException.class);
3242                 vnf = cd.getVnfResourceCustomizationByModelVersionId("npe");
3243         } catch (NullPointerException e) {
3244                 // noop
3245         }
3246     }
3247
3248
3249     @Test
3250     public void getVfModuleByModelCustomizationIdAndVersionTestException(){
3251         mockUpQuery = new MockUp<Query>() {
3252                 String modelVersionId = null;
3253
3254                 @Mock
3255                 public Query setParameter(String name, Object val) {
3256                         if (name.equals("modelVersionId")) modelVersionId = (String)val;
3257                         return this.getMockInstance();
3258                 }
3259
3260                 @Mock
3261                 public Object uniqueResult() {
3262                         if ("nil".equals(modelVersionId)) return null;
3263                         if ("multi".equals(modelVersionId)) throw new org.hibernate.NonUniqueResultException(2);
3264                         if ("he".equals(modelVersionId)) throw new org.hibernate.HibernateException("test case");
3265                         if ("npe".equals(modelVersionId)) throw new NullPointerException();
3266
3267                         VfModule vfModule = new VfModule();
3268                         vfModule.setModelVersion(modelVersionId);
3269                         return vfModule;
3270                 }
3271         };
3272
3273         mockedSession = new MockUp<Session>() {
3274                 @Mock
3275                 public Query createQuery(String hql) {
3276                         return mockUpQuery.getMockInstance();
3277                 }
3278         };
3279
3280         mockCd = new MockUp<CatalogDatabase>() {
3281                 @Mock
3282                 private Session getSession() {
3283                         return mockedSession.getMockInstance();
3284                 }
3285         };
3286
3287         VfModule vm = cd.getVfModuleByModelCustomizationIdAndVersion("4993493","test");
3288         assertEquals("test", vm.getModelVersion());
3289
3290         vm = cd.getVfModuleByModelCustomizationIdAndVersion("4993493", "nil");
3291         assertNull(vm);
3292
3293         try {
3294                 thrown = ExpectedException.none();
3295                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3296                 vm = cd.getVfModuleByModelCustomizationIdAndVersion("4993493", "multi");
3297         } catch (org.hibernate.NonUniqueResultException e) {
3298                 // noop
3299         }
3300
3301         try {
3302                 thrown = ExpectedException.none();
3303                 thrown.expect(org.hibernate.HibernateException.class);
3304                 vm = cd.getVfModuleByModelCustomizationIdAndVersion("4993493", "he");
3305         } catch (org.hibernate.HibernateException e) {
3306                 // noop
3307         }
3308
3309         try {
3310                 thrown = ExpectedException.none();
3311                 thrown.expect(NullPointerException.class);
3312                 vm = cd.getVfModuleByModelCustomizationIdAndVersion("4993493", "npe");
3313         } catch (NullPointerException e) {
3314                 // noop
3315         }
3316     }
3317
3318     @Test
3319     public void getVfModuleCustomizationByVnfModuleCustomizationUuidTest(){
3320         mockUpQuery = new MockUp<Query>() {
3321                 String modelCustomizationUuid = null;
3322
3323                 @Mock
3324                 public Query setParameter(String name, Object val) {
3325                         if (name.equals("modelCustomizationUuid")) modelCustomizationUuid = (String)val;
3326                         return this.getMockInstance();
3327                 }
3328
3329                 @Mock
3330                 public List<VfModuleCustomization> list() {
3331                         if ("nil".equals(modelCustomizationUuid)) return null;
3332                         if ("multi".equals(modelCustomizationUuid)) throw new org.hibernate.NonUniqueResultException(2);
3333                         if ("he".equals(modelCustomizationUuid)) throw new org.hibernate.HibernateException("test case");
3334                         if ("npe".equals(modelCustomizationUuid)) throw new NullPointerException();
3335
3336                         VfModuleCustomization vfModuleCustomization = new VfModuleCustomization();
3337                         vfModuleCustomization.setVfModuleModelUuid(modelCustomizationUuid);
3338                         return Arrays.asList(vfModuleCustomization);
3339                 }
3340         };
3341
3342         mockedSession = new MockUp<Session>() {
3343             @Mock
3344             public Query createQuery(String hql) {
3345                 return mockUpQuery.getMockInstance();
3346             }
3347         };
3348
3349         mockCd = new MockUp<CatalogDatabase>() {
3350             @Mock
3351             private Session getSession() {
3352                 return mockedSession.getMockInstance();
3353             }
3354         };
3355
3356
3357         List<VfModuleCustomization> vmcl = cd.getVfModuleCustomizationByVnfModuleCustomizationUuid("4993493");
3358         assertEquals(1, vmcl.size());
3359         assertEquals("4993493", vmcl.get(0).getVfModuleModelUuid());
3360
3361         vmcl = cd.getVfModuleCustomizationByVnfModuleCustomizationUuid("nil");
3362         assertEquals(0, vmcl.size());
3363
3364         try {
3365                 thrown = ExpectedException.none();
3366                 thrown.expect(org.hibernate.HibernateException.class);
3367                 vmcl = cd.getVfModuleCustomizationByVnfModuleCustomizationUuid("he");
3368         } catch (org.hibernate.HibernateException e) {
3369                 // noop
3370         }
3371
3372         try {
3373                 thrown = ExpectedException.none();
3374                 thrown.expect(NullPointerException.class);
3375                 vmcl = cd.getVfModuleCustomizationByVnfModuleCustomizationUuid("npe");
3376         } catch (NullPointerException e) {
3377                 // noop
3378         }
3379     }
3380
3381     @Test
3382     public void getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionIdTest(){
3383
3384         mockUpQuery = new MockUp<Query>() {
3385
3386             @Mock
3387             public List<VnfResourceCustomization> list() {
3388                 VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
3389                 return Arrays.asList(vnfResourceCustomization);
3390             }
3391         };
3392
3393         mockedSession = new MockUp<Session>() {
3394             @Mock
3395             public Query createQuery(String hql) {
3396                 assertTrue(hql.contains("SELECT vrc FROM VnfResourceCustomization as vrc WHERE vrc.vnfResourceModelUuid IN (SELECT vr.modelUuid FROM VnfResource vr WHERE vr.modelUuid = :modelVersionId)AND vrc.modelInstanceName = :modelCustomizationName"));
3397                 return mockUpQuery.getMockInstance();
3398             }
3399         };
3400
3401         mockCd = new MockUp<CatalogDatabase>() {
3402             @Mock
3403             private Session getSession() {
3404                 return mockedSession.getMockInstance();
3405             }
3406         };
3407         assertNotNull(cd.getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId("modelCustomizationName","modelVersionId"));
3408
3409         VnfResourceCustomization result = cd.getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId("4993493", "test");
3410         assertNotNull(result);
3411     }
3412
3413     @Test
3414     public void getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId_NullReturnTest(){
3415
3416         mockUpQuery = new MockUp<Query>() {
3417
3418             @Mock
3419             public List<VnfResourceCustomization> list() {
3420                 return Arrays.asList();
3421             }
3422         };
3423
3424         mockedSession = new MockUp<Session>() {
3425             @Mock
3426             public Query createQuery(String hql) {
3427                 assertTrue(hql.contains("SELECT vrc FROM VnfResourceCustomization as vrc WHERE vrc.vnfResourceModelUuid IN (SELECT vr.modelUuid FROM VnfResource vr WHERE vr.modelUuid = :modelVersionId)AND vrc.modelInstanceName = :modelCustomizationName"));
3428                 return mockUpQuery.getMockInstance();
3429             }
3430         };
3431
3432         mockCd = new MockUp<CatalogDatabase>() {
3433             @Mock
3434             private Session getSession() {
3435                 return mockedSession.getMockInstance();
3436             }
3437         };
3438
3439         VnfResourceCustomization result = cd.getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId("4993493", "test");
3440         assertNull(result);
3441     }
3442     @Test
3443     public void getAllVfModuleCustomizationsStrTest(){
3444         mockUpQuery = new MockUp<Query>() {
3445                 String vrcMcu = null;
3446
3447                 @Mock
3448                 public Query setParameter(String name, Object val) {
3449                         if (name.equals("vrc_mcu")) vrcMcu = (String)val;
3450                         return this.getMockInstance();
3451                 }
3452
3453                 @Mock
3454                 public List<VnfResCustomToVfModuleCustom> list() {
3455                         if ("nil".equals(vrcMcu)) return null;
3456                         if ("multi".equals(vrcMcu)) throw new org.hibernate.NonUniqueResultException(2);
3457                         if ("he".equals(vrcMcu)) throw new org.hibernate.HibernateException("test case");
3458                         if ("npe".equals(vrcMcu)) throw new NullPointerException();
3459
3460                         VnfResCustomToVfModuleCustom vnfResCustomToVfModuleCustom = new VnfResCustomToVfModuleCustom();
3461                         vnfResCustomToVfModuleCustom.setVfModuleCustModelCustomizationUuid(vrcMcu);
3462                         return Arrays.asList(vnfResCustomToVfModuleCustom);
3463                 }
3464
3465                 @Mock
3466                 public Object uniqueResult() {
3467                         if ("nil".equals(vrcMcu)) return null;
3468                         if ("multi".equals(vrcMcu)) throw new org.hibernate.NonUniqueResultException(2);
3469                         if ("he".equals(vrcMcu)) throw new org.hibernate.HibernateException("test case");
3470                         if ("npe".equals(vrcMcu)) throw new NullPointerException();
3471
3472                         VfModuleCustomization vfModuleCustomization = new VfModuleCustomization();
3473                         vfModuleCustomization.setVfModuleModelUuid(vrcMcu);
3474                         return vfModuleCustomization;
3475                 }
3476
3477         };
3478
3479         mockedSession = new MockUp<Session>() {
3480                 @Mock
3481                 public Query createQuery(String hql) {
3482                         return mockUpQuery.getMockInstance();
3483                 }
3484         };
3485
3486         mockCd = new MockUp<CatalogDatabase>() {
3487                 @Mock
3488                 private Session getSession() {
3489                         return mockedSession.getMockInstance();
3490                 }
3491
3492             @Mock
3493             public VfModule getVfModuleByModelUuid(String modelUuid) {
3494                 return new VfModule();
3495             }
3496         };
3497
3498         ArrayList<VfModuleCustomization> vmcl = cd.getAllVfModuleCustomizations("4993493");
3499         assertNotNull(vmcl);
3500         assertEquals(1, vmcl.size());
3501         assertEquals("4993493", vmcl.get(0).getVfModuleModelUuid());
3502
3503         vmcl = cd.getAllVfModuleCustomizations("nil");
3504         assertNotNull(vmcl);
3505         assertEquals(0, vmcl.size());
3506
3507     }
3508     @Test
3509     public void getVnfResourceByModelUuidTest(){
3510         mockUpQuery = new MockUp<Query>() {
3511                 String modelUuid = null;
3512
3513                 @Mock
3514                 public Query setParameter(String name, Object val) {
3515                         if (name.equals("modelUuid")) modelUuid = (String)val;
3516                         return this.getMockInstance();
3517                 }
3518
3519                 @Mock
3520                 public Object uniqueResult() {
3521                         if ("nil".equals(modelUuid)) return null;
3522                         if ("multi".equals(modelUuid)) throw new org.hibernate.NonUniqueResultException(2);
3523                         if ("he".equals(modelUuid)) throw new org.hibernate.HibernateException("test case");
3524                         if ("npe".equals(modelUuid)) throw new NullPointerException();
3525
3526                         VnfResource vnfResource = new VnfResource();
3527                         vnfResource.setModelUuid(modelUuid);
3528                         return vnfResource;
3529                 }
3530         };
3531
3532         mockedSession = new MockUp<Session>() {
3533                 @Mock
3534                 public Query createQuery(String hql) {
3535                         return mockUpQuery.getMockInstance();
3536                 }
3537         };
3538
3539         mockCd = new MockUp<CatalogDatabase>() {
3540                 @Mock
3541                 private Session getSession() {
3542                         return mockedSession.getMockInstance();
3543                 }
3544         };
3545
3546         VnfResource vr = cd.getVnfResourceByModelUuid("4993493");
3547         assertEquals("4993493", vr.getModelUuid());
3548
3549         vr = cd.getVnfResourceByModelUuid("nil");
3550         assertNull(vr);
3551
3552         try {
3553                 thrown = ExpectedException.none();
3554                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3555                 vr = cd.getVnfResourceByModelUuid("multi");
3556         } catch (org.hibernate.NonUniqueResultException e) {
3557                 // noop
3558         }
3559
3560         try {
3561                 thrown = ExpectedException.none();
3562                 thrown.expect(org.hibernate.HibernateException.class);
3563                 vr = cd.getVnfResourceByModelUuid("he");
3564         } catch (org.hibernate.HibernateException e) {
3565                 // noop
3566         }
3567
3568         try {
3569                 thrown = ExpectedException.none();
3570                 thrown.expect(NullPointerException.class);
3571                 vr = cd.getVnfResourceByModelUuid("npe");
3572         } catch (NullPointerException e) {
3573                 // noop
3574         }
3575     }
3576
3577     @Test
3578     public void getVnfResCustomToVfModuleTest(){
3579         mockUpQuery = new MockUp<Query>() {
3580                 String vfIdValue = null;
3581
3582                 @Mock
3583                 public Query setParameter(String name, Object val) {
3584                         if (name.equals("vfIdValue")) vfIdValue = (String)val;
3585                         return this.getMockInstance();
3586                 }
3587
3588                 @Mock
3589                 public Object uniqueResult() {
3590                         if ("nil".equals(vfIdValue)) return null;
3591                         if ("multi".equals(vfIdValue)) throw new org.hibernate.NonUniqueResultException(2);
3592                         if ("he".equals(vfIdValue)) throw new org.hibernate.HibernateException("test case");
3593                         if ("npe".equals(vfIdValue)) throw new NullPointerException();
3594
3595                         VnfResCustomToVfModuleCustom vr = new VnfResCustomToVfModuleCustom();
3596                         vr.setVfModuleCustModelCustomizationUuid(vfIdValue);
3597                         return vr;
3598                 }
3599         };
3600
3601         mockedSession = new MockUp<Session>() {
3602                 @Mock
3603                 public Query createQuery(String hql) {
3604                         return mockUpQuery.getMockInstance();
3605                 }
3606         };
3607
3608         mockCd = new MockUp<CatalogDatabase>() {
3609                 @Mock
3610                 private Session getSession() {
3611                         return mockedSession.getMockInstance();
3612                 }
3613         };
3614
3615         VnfResCustomToVfModuleCustom vm = cd.getVnfResCustomToVfModule("4993493","test");
3616         assertEquals("test", vm.getVfModuleCustModelCustomizationUuid());
3617
3618         vm = vm = cd.getVnfResCustomToVfModule("4993493", "nil");
3619         assertNull(vm);
3620     }
3621
3622     @Test
3623     public void getVfModulesForVnfResourceTest(){
3624         VnfResource vnfResource = new VnfResource();
3625         vnfResource.setModelUuid("48839");
3626         thrown.expect(Exception.class);
3627         cd.getVfModulesForVnfResource(vnfResource);
3628     }
3629     @Test
3630     public void getVfModulesForVnfResource2Test(){
3631         mockUpQuery = new MockUp<Query>() {
3632                 String vnfResourceModelUUId = null;
3633
3634                 @Mock
3635                 public Query setParameter(String name, Object val) {
3636                         if (name.equals("vnfResourceModelUUId")) vnfResourceModelUUId = (String)val;
3637                         return this.getMockInstance();
3638                 }
3639
3640                 @Mock
3641                 public List<VfModule> list() {
3642                         if ("nil".equals(vnfResourceModelUUId)) return null;
3643                         if ("multi".equals(vnfResourceModelUUId)) throw new org.hibernate.NonUniqueResultException(2);
3644                         if ("he".equals(vnfResourceModelUUId)) throw new org.hibernate.HibernateException("test case");
3645                         if ("npe".equals(vnfResourceModelUUId)) throw new NullPointerException();
3646
3647                         VfModule vfModule = new VfModule();
3648                         vfModule.setVnfResourceModelUUId(vnfResourceModelUUId);
3649                         return Arrays.asList(vfModule);
3650                 }
3651         };
3652
3653         mockedSession = new MockUp<Session>() {
3654                 @Mock
3655                 public Query createQuery(String hql) {
3656                         return mockUpQuery.getMockInstance();
3657                 }
3658         };
3659
3660         mockCd = new MockUp<CatalogDatabase>() {
3661                 @Mock
3662                 private Session getSession() {
3663                         return mockedSession.getMockInstance();
3664                 }
3665         };
3666
3667         List<VfModule> vm = cd.getVfModulesForVnfResource("4993493");
3668         assertNotNull(vm);
3669         assertEquals(1, vm.size());
3670         assertEquals("4993493", vm.get(0).getVnfResourceModelUUId());
3671
3672         vm = cd.getVfModulesForVnfResource("nil");
3673         assertNotNull(vm);
3674         assertEquals(0, vm.size());
3675
3676         try {
3677                 thrown = ExpectedException.none();
3678                 thrown.expect(org.hibernate.HibernateException.class);
3679                 cd.getVfModulesForVnfResource("he");
3680         } catch (org.hibernate.HibernateException e) {
3681                 // noop
3682         }
3683
3684         try {
3685                 thrown = ExpectedException.none();
3686                 thrown.expect(NullPointerException.class);
3687                 cd.getVfModulesForVnfResource("npe");
3688         } catch (NullPointerException e) {
3689                 // noop
3690         }
3691     }
3692
3693     @Test
3694     public void getServiceByUuidTest(){
3695         mockUpQuery = new MockUp<Query>() {
3696                 String serviceModelInvariantUuid = null;
3697
3698                 @Mock
3699                 public Query setParameter(String name, Object val) {
3700                         if (name.equals("serviceModelInvariantUuid")) serviceModelInvariantUuid = (String)val;
3701                         return this.getMockInstance();
3702                 }
3703
3704                 @Mock
3705                 public Object uniqueResult() {
3706                         if ("nil".equals(serviceModelInvariantUuid)) return null;
3707                         if ("multi".equals(serviceModelInvariantUuid)) throw new org.hibernate.NonUniqueResultException(2);
3708                         if ("he".equals(serviceModelInvariantUuid)) throw new org.hibernate.HibernateException("test case");
3709                         if ("npe".equals(serviceModelInvariantUuid)) throw new NullPointerException();
3710
3711                         Service service = new Service();
3712                         service.setModelInvariantUUID(serviceModelInvariantUuid);
3713                         return service;
3714                 }
3715         };
3716
3717         mockedSession = new MockUp<Session>() {
3718                 @Mock
3719                 public Query createQuery(String hql) {
3720                         return mockUpQuery.getMockInstance();
3721                 }
3722         };
3723
3724         mockCd = new MockUp<CatalogDatabase>() {
3725                 @Mock
3726                 private Session getSession() {
3727                         return mockedSession.getMockInstance();
3728                 }
3729         };
3730
3731         Service s = cd.getServiceByUuid("4993493");
3732         assertEquals("4993493", s.getModelInvariantUUID());
3733
3734         s = cd.getServiceByUuid("nil");
3735         assertNull(s);
3736
3737         try {
3738                 thrown = ExpectedException.none();
3739                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3740                 s = cd.getServiceByUuid("multi");
3741         } catch (org.hibernate.NonUniqueResultException e) {
3742                 // noop
3743         }
3744
3745         try {
3746                 thrown = ExpectedException.none();
3747                 thrown.expect(org.hibernate.HibernateException.class);
3748                 s = cd.getServiceByUuid("he");
3749         } catch (org.hibernate.HibernateException e) {
3750                 // noop
3751         }
3752
3753         try {
3754                 thrown = ExpectedException.none();
3755                 thrown.expect(NullPointerException.class);
3756                 s = cd.getServiceByUuid("npe");
3757         } catch (NullPointerException e) {
3758                 // noop
3759         }
3760
3761
3762         thrown.expect(Exception.class);
3763         cd.getServiceByUuid("4993493");
3764     }
3765
3766     @Test
3767     public void getNetworkResourceById2Test(){
3768         mockUpQuery = new MockUp<Query>() {
3769                 Integer id = null;
3770
3771                 @Mock
3772                 public Query setParameter(String name, Object val) {
3773                         if (name.equals("id")) id = (Integer)val;
3774                         return this.getMockInstance();
3775                 }
3776
3777                 @Mock
3778                 public Object uniqueResult() {
3779                         if (id==null || -1 == id) return null;
3780                         if (-2 == id) throw new org.hibernate.NonUniqueResultException(2);
3781                         if (-3 == id) throw new org.hibernate.HibernateException("test case");
3782                         if (-4 == id) throw new NullPointerException();
3783
3784                         NetworkResource networkResource = new NetworkResource();
3785                         networkResource.setModelUUID(Integer.toString(id));
3786                         return networkResource;
3787                 }
3788         };
3789
3790         mockedSession = new MockUp<Session>() {
3791                 @Mock
3792                 public Query createQuery(String hql) {
3793                         return mockUpQuery.getMockInstance();
3794                 }
3795         };
3796
3797         mockCd = new MockUp<CatalogDatabase>() {
3798                 @Mock
3799                 private Session getSession() {
3800                         return mockedSession.getMockInstance();
3801                 }
3802         };
3803
3804         NetworkResource nr = cd.getNetworkResourceById(4993493);
3805         assertEquals("4993493", nr.getModelUUID());
3806
3807         nr = cd.getNetworkResourceById(-1);
3808         assertNull(nr);
3809
3810         try {
3811                 thrown = ExpectedException.none();
3812                 thrown.expect(org.hibernate.NonUniqueResultException.class);
3813                 nr = cd.getNetworkResourceById(-2);
3814         } catch (org.hibernate.NonUniqueResultException e) {
3815                 // noop
3816         }
3817
3818         try {
3819                 thrown = ExpectedException.none();
3820                 thrown.expect(org.hibernate.HibernateException.class);
3821                 nr = cd.getNetworkResourceById(-3);
3822         } catch (org.hibernate.HibernateException e) {
3823                 // noop
3824         }
3825
3826         try {
3827                 thrown = ExpectedException.none();
3828                 thrown.expect(NullPointerException.class);
3829                 nr = cd.getNetworkResourceById(-4);
3830         } catch (NullPointerException e) {
3831                 // noop
3832         }
3833     }
3834
3835     @Test
3836     public void getNetworkResourceByIdTest(){
3837         mockUpQuery = new MockUp<Query>() {
3838             @Mock
3839             public Object uniqueResult() {
3840                 VfModule vm = new VfModule();
3841                 vm.setModelInvariantUuid("4993493");
3842                 return vm;
3843             }
3844         };
3845
3846         mockedSession = new MockUp<Session>() {
3847             @Mock
3848             public Query createQuery(String hql) {
3849                 return mockUpQuery.getMockInstance();
3850             }
3851         };
3852
3853         mockCd = new MockUp<CatalogDatabase>() {
3854             @Mock
3855             private Session getSession() {
3856                 return mockedSession.getMockInstance();
3857             }
3858         };
3859
3860         VfModule vm = cd.getVfModuleTypeByUuid("4993493");
3861         assertEquals("4993493", vm.getModelInvariantUuid());
3862     }
3863
3864     @Test
3865     public void getNetworkResourceByIdNullTest(){
3866         mockUpQuery = new MockUp<Query>() {
3867             @Mock
3868             public Object uniqueResult() {
3869                 return null;
3870             }
3871         };
3872
3873         mockedSession = new MockUp<Session>() {
3874             @Mock
3875             public Query createQuery(String hql) {
3876                 return mockUpQuery.getMockInstance();
3877             }
3878         };
3879
3880         mockCd = new MockUp<CatalogDatabase>() {
3881             @Mock
3882             private Session getSession() {
3883                 return mockedSession.getMockInstance();
3884             }
3885         };
3886
3887         VfModule vm = cd.getVfModuleTypeByUuid("4993493");
3888         assertNull(null);
3889     }
3890
3891     @Test
3892     public void getNetworkResourceByIdNonUniqueTest(){
3893         mockUpQuery = new MockUp<Query>() {
3894             @Mock
3895             public Object uniqueResult() {
3896                 throw new org.hibernate.NonUniqueResultException(2);
3897             }
3898         };
3899
3900         mockedSession = new MockUp<Session>() {
3901             @Mock
3902             public Query createQuery(String hql) {
3903                 return mockUpQuery.getMockInstance();
3904             }
3905         };
3906
3907         mockCd = new MockUp<CatalogDatabase>() {
3908             @Mock
3909             private Session getSession() {
3910                 return mockedSession.getMockInstance();
3911             }
3912         };
3913
3914         thrown.expect(org.hibernate.NonUniqueResultException.class);
3915         VfModule vm = cd.getVfModuleTypeByUuid("4993493");
3916     }
3917
3918     @Test
3919     public void getNetworkResourceByIdHibernateExceptionTest(){
3920         mockUpQuery = new MockUp<Query>() {
3921             @Mock
3922             public Object uniqueResult() {
3923                 throw new org.hibernate.HibernateException("test case");
3924             }
3925         };
3926
3927         mockedSession = new MockUp<Session>() {
3928             @Mock
3929             public Query createQuery(String hql) {
3930                 return mockUpQuery.getMockInstance();
3931             }
3932         };
3933
3934         mockCd = new MockUp<CatalogDatabase>() {
3935             @Mock
3936             private Session getSession() {
3937                 return mockedSession.getMockInstance();
3938             }
3939         };
3940
3941         thrown.expect(org.hibernate.HibernateException.class);
3942         VfModule vm = cd.getVfModuleTypeByUuid("4993493");
3943     }
3944
3945     @Test
3946     public void getNetworkResourceByIdExceptionTest(){
3947         mockUpQuery = new MockUp<Query>() {
3948             @Mock
3949             public Object uniqueResult() {
3950                 throw new NullPointerException();
3951             }
3952         };
3953
3954         mockedSession = new MockUp<Session>() {
3955             @Mock
3956             public Query createQuery(String hql) {
3957                 return mockUpQuery.getMockInstance();
3958             }
3959         };
3960
3961         mockCd = new MockUp<CatalogDatabase>() {
3962             @Mock
3963             private Session getSession() {
3964                 return mockedSession.getMockInstance();
3965             }
3966         };
3967
3968         thrown.expect(NullPointerException.class);
3969         VfModule vm = cd.getVfModuleTypeByUuid("4993493");
3970     }
3971
3972     @Test
3973     public void isEmptyOrNullTest(){
3974         boolean is = cd.isEmptyOrNull("4993493");
3975         assertFalse(is);
3976     }
3977     @Test
3978     public void getSTRTest(){
3979         mockUpQuery = new MockUp<Query>() {
3980
3981             @Mock
3982             public List<ServiceToResourceCustomization> list() {
3983                 ServiceToResourceCustomization vnfResourceCustomization = new ServiceToResourceCustomization();
3984                 return Arrays.asList(vnfResourceCustomization);
3985             }
3986         };
3987
3988         mockedSession = new MockUp<Session>() {
3989             @Mock
3990             public Query createQuery(String hql) {
3991                 return mockUpQuery.getMockInstance();
3992             }
3993         };
3994
3995         mockCd = new MockUp<CatalogDatabase>() {
3996             @Mock
3997             private Session getSession() {
3998                 return mockedSession.getMockInstance();
3999             }
4000         };
4001
4002         List<ServiceToResourceCustomization> str = cd.getSTR("4993493", "test", "vnf");
4003         assertFalse(str.isEmpty());
4004
4005     }
4006     @Test
4007     public void getVRCtoVFMCTest(){
4008         mockUpQuery = new MockUp<Query>() {
4009                 String vrcMcu = null;
4010
4011                 @Mock
4012                 public Query setParameter(String name, Object val) {
4013                         if (name.equals("vrc_mcu")) vrcMcu = (String)val;
4014                         return this.getMockInstance();
4015                 }
4016
4017                 @Mock
4018                 public List<VnfResCustomToVfModuleCustom> list() {
4019                         if ("nil".equals(vrcMcu)) return null;
4020                         if ("multi".equals(vrcMcu)) throw new org.hibernate.NonUniqueResultException(2);
4021                         if ("he".equals(vrcMcu)) throw new org.hibernate.HibernateException("test case");
4022                         if ("npe".equals(vrcMcu)) throw new NullPointerException();
4023
4024                         VnfResCustomToVfModuleCustom vnfResCustomToVfModuleCustom = new VnfResCustomToVfModuleCustom();
4025                         vnfResCustomToVfModuleCustom.setVfModuleCustModelCustomizationUuid(vrcMcu);
4026                         return Arrays.asList(vnfResCustomToVfModuleCustom);
4027                 }
4028         };
4029
4030         mockedSession = new MockUp<Session>() {
4031                 @Mock
4032                 public Query createQuery(String hql) {
4033                         return mockUpQuery.getMockInstance();
4034                 }
4035         };
4036
4037         mockCd = new MockUp<CatalogDatabase>() {
4038             @Mock
4039             private Session getSession() {
4040                 return mockedSession.getMockInstance();
4041             }
4042         };
4043
4044         List<VnfResCustomToVfModuleCustom> vrCtoVFMC = cd.getVRCtoVFMC("", "null");
4045         assertNull(vrCtoVFMC);
4046
4047         vrCtoVFMC = cd.getVRCtoVFMC("4993493", "388492");
4048         assertNotNull(vrCtoVFMC);
4049         assertEquals(1, vrCtoVFMC.size());
4050         assertEquals("4993493", vrCtoVFMC.get(0).getVfModuleCustModelCustomizationUuid());
4051
4052         vrCtoVFMC = cd.getVRCtoVFMC("nil", "388492");
4053         assertNotNull(vrCtoVFMC);
4054         assertEquals(0, vrCtoVFMC.size());
4055
4056     }
4057     @Test
4058     public void getTempNetworkHeatTemplateLookupTest(){
4059         mockUpQuery = new MockUp<Query>() {
4060
4061             @Mock
4062             public List<TempNetworkHeatTemplateLookup> list() {
4063                 TempNetworkHeatTemplateLookup vnfResourceCustomization = new TempNetworkHeatTemplateLookup();
4064                 return Arrays.asList(vnfResourceCustomization);
4065             }
4066         };
4067
4068         mockedSession = new MockUp<Session>() {
4069             @Mock
4070             public Query createQuery(String hql) {
4071                 return mockUpQuery.getMockInstance();
4072             }
4073         };
4074
4075         mockCd = new MockUp<CatalogDatabase>() {
4076             @Mock
4077             private Session getSession() {
4078                 return mockedSession.getMockInstance();
4079             }
4080         };
4081         List<TempNetworkHeatTemplateLookup> tempNetworkHeatTemplateLookup = cd.getTempNetworkHeatTemplateLookup("4993493");
4082         assertFalse(tempNetworkHeatTemplateLookup.isEmpty());
4083     }
4084
4085     @Test
4086     public void getAllNetworksByServiceModelUuidTest(){
4087         mockUpQuery = new MockUp<Query>() {
4088                 String smu = null;
4089
4090                 @Mock
4091                 public Query setParameter(String name, Object val) {
4092                         if (name.equals("smu")) smu = (String)val;
4093                         return this.getMockInstance();
4094                 }
4095
4096                 @Mock
4097                 public List<ServiceToResourceCustomization> list() {
4098                         if ("nil".equals(smu)) return null;
4099                         if ("multi".equals(smu)) throw new org.hibernate.NonUniqueResultException(2);
4100                         if ("he".equals(smu)) throw new org.hibernate.HibernateException("test case");
4101                         if ("npe".equals(smu)) throw new NullPointerException();
4102
4103                         ServiceToResourceCustomization src = new ServiceToResourceCustomization();
4104                         src.setServiceModelUUID(smu);
4105                         return Arrays.asList(src);
4106                 }
4107         };
4108
4109         mockedSession = new MockUp<Session>() {
4110             @Mock
4111             public Query createQuery(String hql) {
4112                 return mockUpQuery.getMockInstance();
4113             }
4114         };
4115
4116         mockCd = new MockUp<CatalogDatabase>() {
4117             @Mock
4118             private Session getSession() {
4119                 return mockedSession.getMockInstance();
4120             }
4121
4122             @Mock
4123             public List<NetworkResourceCustomization> getAllNetworksByNetworkModelCustomizationUuid(String networkModelCustomizationUuid) {
4124                 NetworkResourceCustomization nrc = new NetworkResourceCustomization();
4125                 nrc.setNetworkResourceModelUuid(networkModelCustomizationUuid);
4126                 return Arrays.asList(nrc);
4127             }
4128         };
4129
4130         List<NetworkResourceCustomization> nrcl = cd.getAllNetworksByServiceModelUuid("4993493");
4131         assertNotNull(nrcl);
4132         assertEquals(1, nrcl.size());
4133
4134         nrcl = cd.getAllNetworksByServiceModelUuid("nil");
4135         assertNotNull(nrcl);
4136         assertEquals(0, nrcl.size());
4137 /*
4138         try {
4139                 thrown = ExpectedException.none();
4140                 thrown.expect(org.hibernate.NonUniqueResultException.class);
4141                 vm = cd.getVfModuleType("type", "multi");
4142         } catch (org.hibernate.NonUniqueResultException e) {
4143                 // noop
4144         }
4145
4146         try {
4147                 thrown = ExpectedException.none();
4148                 thrown.expect(org.hibernate.HibernateException.class);
4149                 vm = cd.getVfModuleType("type", "he");
4150         } catch (org.hibernate.HibernateException e) {
4151                 // noop
4152         }
4153
4154         try {
4155                 thrown = ExpectedException.none();
4156                 thrown.expect(NullPointerException.class);
4157                 vm = cd.getVfModuleType("type", "npe");
4158         } catch (NullPointerException e) {
4159                 // noop
4160         }
4161
4162         assertEquals(cd.getAllNetworksByServiceModelUuid("4993493").size(), 0);
4163         */
4164     }
4165
4166     @Test
4167     public void getAllNetworksByServiceModelInvariantUuidTest(){
4168         mockUpQuery = new MockUp<Query>() {
4169                 String serviceModelInvariantUuid = null;
4170
4171                 @Mock
4172                 public Query setParameter(String name, Object val) {
4173                         if (name.equals("serviceModelInvariantUuid")) serviceModelInvariantUuid = (String)val;
4174                         return this.getMockInstance();
4175                 }
4176
4177                 @Mock
4178                 public List<Service>  list() {
4179                         if ("nil".equals(serviceModelInvariantUuid)) return new ArrayList<Service>();
4180                         if ("multi".equals(serviceModelInvariantUuid)) throw new org.hibernate.NonUniqueResultException(2);
4181                         if ("he".equals(serviceModelInvariantUuid)) throw new org.hibernate.HibernateException("test case");
4182                         if ("npe".equals(serviceModelInvariantUuid)) throw new NullPointerException();
4183
4184                         Service nrc = new Service();
4185                         nrc.setModelInvariantUUID(serviceModelInvariantUuid);
4186                         nrc.setModelUUID(serviceModelInvariantUuid);
4187                         return Arrays.asList(nrc);
4188                 }
4189         };
4190
4191         mockedSession = new MockUp<Session>() {
4192                 @Mock
4193                 public Query createQuery(String hql) {
4194                         return mockUpQuery.getMockInstance();
4195                 }
4196         };
4197
4198         mockCd = new MockUp<CatalogDatabase>() {
4199                 @Mock
4200                 private Session getSession() {
4201                         return mockedSession.getMockInstance();
4202                 }
4203
4204                 @Mock
4205             public List<NetworkResourceCustomization> getAllNetworksByServiceModelUuid(String serviceModelUuid) {
4206                         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
4207                         nrc.setNetworkResourceModelUuid(serviceModelUuid);
4208                         return Arrays.asList(nrc);
4209                 }
4210         };
4211
4212         List<NetworkResourceCustomization> nrcl = cd.getAllNetworksByServiceModelInvariantUuid("4993493");
4213         assertNotNull(nrcl);
4214         assertEquals(1, nrcl.size());
4215         assertEquals("4993493", nrcl.get(0).getNetworkResourceModelUuid());
4216
4217         nrcl = cd.getAllNetworksByServiceModelInvariantUuid("nil");
4218         assertNotNull(nrcl);
4219         assertEquals(0, nrcl.size());
4220     }
4221     @Test
4222     public void getAllNetworksByServiceModelInvariantUuid2Test(){
4223         mockUpQuery = new MockUp<Query>() {
4224                 String serviceModelInvariantUuid = null;
4225
4226                 @Mock
4227                 public Query setParameter(String name, Object val) {
4228                         if (name.equals("serviceModelInvariantUuid")) serviceModelInvariantUuid = (String)val;
4229                         return this.getMockInstance();
4230                 }
4231
4232                 @Mock
4233                 public List<Service> list() {
4234                         if ("nil".equals(serviceModelInvariantUuid)) return new ArrayList<Service>();
4235                         if ("multi".equals(serviceModelInvariantUuid)) throw new org.hibernate.NonUniqueResultException(2);
4236                         if ("he".equals(serviceModelInvariantUuid)) throw new org.hibernate.HibernateException("test case");
4237                         if ("npe".equals(serviceModelInvariantUuid)) throw new NullPointerException();
4238
4239                         Service service = new Service();
4240                         service.setModelInvariantUUID(serviceModelInvariantUuid);
4241                         service.setModelUUID(serviceModelInvariantUuid);
4242                         return Arrays.asList(service);
4243                 }
4244         };
4245
4246         mockedSession = new MockUp<Session>() {
4247                 @Mock
4248                 public Query createQuery(String hql) {
4249                         return mockUpQuery.getMockInstance();
4250                 }
4251         };
4252
4253         mockCd = new MockUp<CatalogDatabase>() {
4254                 @Mock
4255                 private Session getSession() {
4256                         return mockedSession.getMockInstance();
4257                 }
4258
4259                 @Mock
4260             public List<NetworkResourceCustomization> getAllNetworksByServiceModelUuid(String serviceModelUuid) {
4261                         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
4262                         nrc.setModelCustomizationUuid(serviceModelUuid);
4263                         return Arrays.asList(nrc);
4264                 }
4265         };
4266
4267         List<NetworkResourceCustomization> nrcl =  cd.getAllNetworksByServiceModelInvariantUuid("4993493","test");
4268         assertNotNull(nrcl);
4269         assertEquals(1, nrcl.size());
4270         assertEquals("4993493", nrcl.get(0).getModelCustomizationUuid());
4271
4272         nrcl =  cd.getAllNetworksByServiceModelInvariantUuid("nil","test");
4273         assertNotNull(nrcl);
4274         assertEquals(0, nrcl.size());
4275     }
4276
4277     @Test
4278     public void getAllNetworksByNetworkModelCustomizationUuidTest(){
4279         mockUpQuery = new MockUp<Query>() {
4280                 String networkModelCustomizationUuid = null;
4281
4282                 @Mock
4283                 public Query setParameter(String name, Object val) {
4284                         if (name.equals("networkModelCustomizationUuid")) networkModelCustomizationUuid = (String)val;
4285                         return this.getMockInstance();
4286                 }
4287
4288                 @Mock
4289                 public List<NetworkResourceCustomization> list() {
4290                         if ("nil".equals(networkModelCustomizationUuid)) return new ArrayList<NetworkResourceCustomization>();
4291                         if ("multi".equals(networkModelCustomizationUuid)) throw new org.hibernate.NonUniqueResultException(2);
4292                         if ("he".equals(networkModelCustomizationUuid)) throw new org.hibernate.HibernateException("test case");
4293                         if ("npe".equals(networkModelCustomizationUuid)) throw new NullPointerException();
4294
4295                         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
4296                         nrc.setNetworkResourceModelUuid(networkModelCustomizationUuid);
4297                         return Arrays.asList(nrc);
4298                 }
4299         };
4300
4301         mockedSession = new MockUp<Session>() {
4302                 @Mock
4303                 public Query createQuery(String hql) {
4304                         return mockUpQuery.getMockInstance();
4305                 }
4306         };
4307
4308         mockCd = new MockUp<CatalogDatabase>() {
4309                 @Mock
4310                 private Session getSession() {
4311                         return mockedSession.getMockInstance();
4312                 }
4313
4314                 @Mock
4315             public NetworkResource getNetworkResourceById(String id) {
4316                         NetworkResource nr = new NetworkResource ();
4317                         return nr;
4318                 }
4319         };
4320
4321         List<NetworkResourceCustomization> nrcl = cd.getAllNetworksByNetworkModelCustomizationUuid("4993493");
4322         assertNotNull(nrcl);
4323         assertEquals(1, nrcl.size());
4324         assertEquals("4993493", nrcl.get(0).getNetworkResourceModelUuid());
4325
4326         nrcl = cd.getAllNetworksByNetworkModelCustomizationUuid("nil");
4327         assertNotNull(nrcl);
4328         assertEquals(0, nrcl.size());
4329     }
4330
4331     @Test
4332     public void getAllNetworksByNetworkTypeTest(){
4333         mockUpQuery = new MockUp<Query>() {
4334                 String networkResourceId = null;
4335
4336                 @Mock
4337                 public Query setParameter(String name, Object val) {
4338                         if (name.equals("networkResourceId")) networkResourceId = (String)val;
4339                         return this.getMockInstance();
4340                 }
4341
4342                 @Mock
4343                 public List<NetworkResourceCustomization> list() {
4344                         if ("nil".equals(networkResourceId)) return null;
4345                         if ("multi".equals(networkResourceId)) throw new org.hibernate.NonUniqueResultException(2);
4346                         if ("he".equals(networkResourceId)) throw new org.hibernate.HibernateException("test case");
4347                         if ("npe".equals(networkResourceId)) throw new NullPointerException();
4348
4349                         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
4350                         nrc.setNetworkResourceModelUuid(networkResourceId);
4351                         return Arrays.asList(nrc);
4352                 }
4353         };
4354
4355         mockedSession = new MockUp<Session>() {
4356                 @Mock
4357                 public Query createQuery(String hql) {
4358                         return mockUpQuery.getMockInstance();
4359                 }
4360         };
4361
4362         mockCd = new MockUp<CatalogDatabase>() {
4363                 @Mock
4364                 private Session getSession() {
4365                         return mockedSession.getMockInstance();
4366                 }
4367
4368                 @Mock
4369             public NetworkResource getNetworkResource(String networkType) {
4370                         if ("nil".equals(networkType)) return null;
4371
4372                         NetworkResource nr = new NetworkResource();
4373                         nr.setNeutronNetworkType(networkType);
4374                         return nr;
4375                 }
4376         };
4377
4378         List<NetworkResourceCustomization> nrcl = cd.getAllNetworksByNetworkType("4993493");
4379         assertNotNull(nrcl);
4380         assertEquals(1, nrcl.size());
4381         assertEquals("4993493", nrcl.get(0).getNetworkType());
4382
4383         nrcl = cd.getAllNetworksByNetworkType("nil");
4384         assertNotNull(nrcl);
4385         assertEquals(0, nrcl.size());
4386     }
4387     @Test
4388     public void getAllVfmcForVrcTest(){
4389         VnfResourceCustomization re = new VnfResourceCustomization();
4390         re.setModelCustomizationUuid("377483");
4391         thrown.expect(Exception.class);
4392         cd.getAllVfmcForVrc(re);
4393     }
4394     @Test
4395     public void getAllVnfsByServiceModelUuidTest(){
4396         thrown.expect(Exception.class);
4397         cd.getAllVnfsByServiceModelUuid("4993493");
4398     }
4399     @Test
4400     public void getAllVnfsByServiceModelInvariantUuidTest(){
4401         thrown.expect(Exception.class);
4402         cd.getAllVnfsByServiceModelInvariantUuid("4993493");
4403     }
4404     @Test
4405     public void getAllVnfsByServiceModelInvariantUuid2Test(){
4406         thrown.expect(Exception.class);
4407         cd.getAllVnfsByServiceModelInvariantUuid("4993493","test");
4408     }
4409     @Test
4410     public void getAllVnfsByServiceNameTest(){
4411         thrown.expect(Exception.class);
4412         cd.getAllVnfsByServiceName("4993493","test");
4413     }
4414     @Test
4415     public void getAllVnfsByServiceName2Test(){
4416         thrown.expect(Exception.class);
4417         cd.getAllVnfsByServiceName("4993493");
4418     }
4419     @Test
4420     public void getAllVnfsByVnfModelCustomizationUuidTest(){
4421         thrown.expect(Exception.class);
4422         cd.getAllVnfsByVnfModelCustomizationUuid("4993493");
4423     }
4424     @Test
4425     public void getAllAllottedResourcesByServiceModelUuidTest(){
4426         mockUpQuery = new MockUp<Query>() {
4427
4428             @Mock
4429             public List<ServiceToResourceCustomization> list() {
4430                 ServiceToResourceCustomization vnfResourceCustomization = new ServiceToResourceCustomization();
4431                 return Arrays.asList(vnfResourceCustomization);
4432             }
4433         };
4434         mockUpQuery2 = new MockUp<Query>() {
4435
4436             @Mock
4437             public List<AllottedResourceCustomization> list() {
4438                 AllottedResourceCustomization vnfResourceCustomization = new AllottedResourceCustomization();
4439                 return Arrays.asList(vnfResourceCustomization);
4440             }
4441         };
4442         mockUpQuery3 = new MockUp<Query>() {
4443
4444             @Mock
4445             public List<AllottedResource> list() {
4446                 AllottedResource vnfResourceCustomization = new AllottedResource();
4447                 return Arrays.asList(vnfResourceCustomization);
4448             }
4449         };
4450         mockedSession = new MockUp<Session>() {
4451             @Mock
4452             public Query createQuery(String hql) {
4453                 if(hql.contains("ServiceToResourceCustomization")){
4454                     return mockUpQuery.getMockInstance();
4455
4456                 }else if(hql.contains("AllottedResource " )){
4457                     return mockUpQuery3.getMockInstance();
4458
4459                 } else{
4460                     return mockUpQuery2.getMockInstance();
4461                 }
4462
4463
4464             }
4465         };
4466
4467         mockCd = new MockUp<CatalogDatabase>() {
4468             @Mock
4469             private Session getSession() {
4470                 return mockedSession.getMockInstance();
4471             }
4472         };
4473
4474         List<AllottedResourceCustomization> allAllottedResourcesByServiceModelUuid = cd.getAllAllottedResourcesByServiceModelUuid("4993493");
4475         assertFalse(allAllottedResourcesByServiceModelUuid.isEmpty());
4476     }
4477     @Test
4478     public void getAllAllottedResourcesByServiceModelInvariantUuidTest(){
4479         thrown.expect(Exception.class);
4480         cd.getAllAllottedResourcesByServiceModelInvariantUuid("4993493");
4481     }
4482     @Test
4483     public void getAllAllottedResourcesByServiceModelInvariantUuid2Test(){
4484
4485         mockUpQuery = new MockUp<Query>() {
4486
4487             @Mock
4488             public List<ServiceToResourceCustomization> list() {
4489                 ServiceToResourceCustomization vnfResourceCustomization = new ServiceToResourceCustomization();
4490                 return Arrays.asList(vnfResourceCustomization);
4491             }
4492         };
4493         mockUpQuery2 = new MockUp<Query>() {
4494
4495             @Mock
4496             public List<AllottedResourceCustomization> list() {
4497                 AllottedResourceCustomization vnfResourceCustomization = new AllottedResourceCustomization();
4498                 return Arrays.asList(vnfResourceCustomization);
4499             }
4500         };
4501         mockUpQuery3 = new MockUp<Query>() {
4502
4503             @Mock
4504             public List<AllottedResource> list() {
4505                 AllottedResource vnfResourceCustomization = new AllottedResource();
4506                 return Arrays.asList(vnfResourceCustomization);
4507             }
4508         };
4509         mockUpQuery4 = new MockUp<Query>() {
4510
4511             @Mock
4512             public List<Service> list() {
4513                 Service vnfResourceCustomization = new Service();
4514                 return Arrays.asList(vnfResourceCustomization);
4515             }
4516         };
4517         mockedSession = new MockUp<Session>() {
4518             @Mock
4519             public Query createQuery(String hql) {
4520                 if(hql.contains("ServiceToResourceCustomization")){
4521                     return mockUpQuery.getMockInstance();
4522
4523                 }else if(hql.contains("AllottedResource " )){
4524                     return mockUpQuery3.getMockInstance();
4525
4526                 } else if(hql.contains(" Service ")){
4527                     return mockUpQuery4.getMockInstance();
4528                 }else{
4529                     return mockUpQuery2.getMockInstance();
4530                 }
4531
4532
4533             }
4534         };
4535
4536         mockCd = new MockUp<CatalogDatabase>() {
4537             @Mock
4538             private Session getSession() {
4539                 return mockedSession.getMockInstance();
4540             }
4541         };
4542
4543
4544         List<AllottedResourceCustomization> allottedResourceCustomizations = cd.getAllAllottedResourcesByServiceModelInvariantUuid("4993493", "test");
4545         assertFalse(allottedResourceCustomizations.isEmpty());
4546     }
4547     @Test
4548     public void getAllAllottedResourcesByArModelCustomizationUuidTest(){
4549         thrown.expect(Exception.class);
4550         cd.getAllAllottedResourcesByArModelCustomizationUuid("4993493");
4551     }
4552     @Test
4553     public void getAllottedResourceByModelUuidTest(){
4554         thrown.expect(Exception.class);
4555         cd.getAllottedResourceByModelUuid("4993493");
4556     }
4557     @Test
4558     public void getAllResourcesByServiceModelUuidTest(){
4559         thrown.expect(Exception.class);
4560         cd.getAllResourcesByServiceModelUuid("4993493");
4561     }
4562     @Test
4563     public void getAllResourcesByServiceModelInvariantUuidTest(){
4564         thrown.expect(Exception.class);
4565         cd.getAllResourcesByServiceModelInvariantUuid("4993493");
4566     }
4567
4568     @Test
4569     public void getAllResourcesByServiceModelInvariantUuid2Test(){
4570         thrown.expect(Exception.class);
4571         cd.getAllResourcesByServiceModelInvariantUuid("4993493","test");
4572     }
4573     @Test
4574     public void getSingleNetworkByModelCustomizationUuidTest(){
4575         thrown.expect(Exception.class);
4576         cd.getSingleNetworkByModelCustomizationUuid("4993493");
4577     }
4578     @Test
4579     public void getSingleAllottedResourceByModelCustomizationUuidTest(){
4580         thrown.expect(Exception.class);
4581         cd.getSingleAllottedResourceByModelCustomizationUuid("4993493");
4582     }
4583     @Test
4584     public void getVfModuleRecipeTest(){
4585         thrown.expect(Exception.class);
4586         cd.getVfModuleRecipe("4993493","test","get");
4587     }
4588     @Test
4589     public void getVfModuleTest(){
4590         mockUpQuery = new MockUp<Query>() {
4591
4592             @Mock
4593             public List<VfModule> list() {
4594                 VfModule vnfResourceCustomization = new VfModule();
4595                 return Arrays.asList(vnfResourceCustomization);
4596             }
4597         };
4598
4599         mockedSession = new MockUp<Session>() {
4600             @Mock
4601             public Query createQuery(String hql) {
4602                 return mockUpQuery.getMockInstance();
4603             }
4604         };
4605
4606         mockCd = new MockUp<CatalogDatabase>() {
4607             @Mock
4608             private Session getSession() {
4609                 return mockedSession.getMockInstance();
4610             }
4611         };
4612
4613         List<VfModule> vfModule = cd.getVfModule("4993493", "test", "get", "v2", "vnf");
4614         assertFalse(vfModule.isEmpty());
4615     }
4616     @Test
4617     public void getVnfComponentsRecipeTest(){
4618         thrown.expect(Exception.class);
4619         cd.getVnfComponentsRecipe("4993493","test","v2","vnf","get","3992");
4620     }
4621     @Test
4622     public void getVnfComponentsRecipeByVfModuleTest(){
4623         List <VfModule> resultList = new ArrayList<>();
4624         VfModule m = new VfModule();
4625         resultList.add(m);
4626         thrown.expect(Exception.class);
4627         cd.getVnfComponentsRecipeByVfModule(resultList,"4993493");
4628     }
4629     @Test
4630     public void getAllVnfResourcesTest(){
4631         mockUpQuery = new MockUp<Query>() {
4632
4633             @Mock
4634             public List<VnfResource> list() {
4635                 VnfResource vnfResourceCustomization = new VnfResource();
4636                 return Arrays.asList(vnfResourceCustomization);
4637             }
4638         };
4639
4640         mockedSession = new MockUp<Session>() {
4641             @Mock
4642             public Query createQuery(String hql) {
4643                 assertTrue(hql.contains("FROM VnfResource"));
4644                 return mockUpQuery.getMockInstance();
4645             }
4646         };
4647
4648         mockCd = new MockUp<CatalogDatabase>() {
4649             @Mock
4650             private Session getSession() {
4651                 return mockedSession.getMockInstance();
4652             }
4653         };
4654         List<VnfResource> allVnfResources = cd.getAllVnfResources();
4655         assertFalse(allVnfResources.isEmpty());
4656     }
4657     @Test
4658     public void getVnfResourcesByRoleTest(){
4659         mockUpQuery = new MockUp<Query>() {
4660
4661             @Mock
4662             public List<VnfResource> list() {
4663                 VnfResource vnfResourceCustomization = new VnfResource();
4664                 return Arrays.asList(vnfResourceCustomization);
4665             }
4666         };
4667
4668         mockedSession = new MockUp<Session>() {
4669             @Mock
4670             public Query createQuery(String hql) {
4671                 assertTrue(hql.contains("FROM VnfResource WHERE vnfRole = :vnfRole"));
4672                 return mockUpQuery.getMockInstance();
4673             }
4674         };
4675
4676         mockCd = new MockUp<CatalogDatabase>() {
4677             @Mock
4678             private Session getSession() {
4679                 return mockedSession.getMockInstance();
4680             }
4681         };
4682         List<VnfResource> vnfResourcesByRole = cd.getVnfResourcesByRole("4993493");
4683         assertFalse(vnfResourcesByRole.isEmpty());
4684     }
4685     @Test
4686     public void getVnfResourceCustomizationsByRoleTest(){
4687         mockUpQuery = new MockUp<Query>() {
4688
4689             @Mock
4690             public List<VnfResourceCustomization> list() {
4691                 VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
4692                 return Arrays.asList(vnfResourceCustomization);
4693             }
4694         };
4695
4696         mockedSession = new MockUp<Session>() {
4697             @Mock
4698             public Query createQuery(String hql) {
4699                 assertTrue(hql.contains("FROM VnfResourceCustomization WHERE nfRole = :vnfRole"));
4700                 return mockUpQuery.getMockInstance();
4701             }
4702         };
4703
4704         mockCd = new MockUp<CatalogDatabase>() {
4705             @Mock
4706             private Session getSession() {
4707                 return mockedSession.getMockInstance();
4708             }
4709         };
4710         List<VnfResourceCustomization> vnfResourceCustomizationsByRole = cd.getVnfResourceCustomizationsByRole("4993493");
4711         assertFalse(vnfResourceCustomizationsByRole.isEmpty());
4712     }
4713     @Test
4714     public void getAllNetworkResourcesTest(){
4715         mockUpQuery = new MockUp<Query>() {
4716
4717             @Mock
4718             public List<NetworkResource> list() {
4719                 NetworkResource vnfResourceCustomization = new NetworkResource();
4720                 return Arrays.asList(vnfResourceCustomization);
4721             }
4722         };
4723
4724         mockedSession = new MockUp<Session>() {
4725             @Mock
4726             public Query createQuery(String hql) {
4727                 assertTrue(hql.contains("FROM NetworkResource"));
4728                 return mockUpQuery.getMockInstance();
4729             }
4730         };
4731
4732         mockCd = new MockUp<CatalogDatabase>() {
4733             @Mock
4734             private Session getSession() {
4735                 return mockedSession.getMockInstance();
4736             }
4737         };
4738         List<NetworkResource> allNetworkResources = cd.getAllNetworkResources();
4739         assertFalse(allNetworkResources.isEmpty());
4740     }
4741     @Test
4742     public void getAllNetworkResourceCustomizationsTest(){
4743         mockUpQuery = new MockUp<Query>() {
4744
4745             @Mock
4746             public List<NetworkResourceCustomization> list() {
4747                 NetworkResourceCustomization vnfResourceCustomization = new NetworkResourceCustomization();
4748                 return Arrays.asList(vnfResourceCustomization);
4749             }
4750         };
4751
4752         mockedSession = new MockUp<Session>() {
4753             @Mock
4754             public Query createQuery(String hql) {
4755                 assertTrue(hql.contains("FROM NetworkResourceCustomization"));
4756                 return mockUpQuery.getMockInstance();
4757             }
4758         };
4759
4760         mockCd = new MockUp<CatalogDatabase>() {
4761             @Mock
4762             private Session getSession() {
4763                 return mockedSession.getMockInstance();
4764             }
4765         };
4766         List<NetworkResourceCustomization> allNetworkResourceCustomizations = cd.getAllNetworkResourceCustomizations();
4767         assertFalse(allNetworkResourceCustomizations.isEmpty());
4768     }
4769     @Test
4770     public void getAllVfModulesTest(){
4771         mockUpQuery = new MockUp<Query>() {
4772
4773             @Mock
4774             public List<VfModule> list() {
4775                 VfModule vnfResourceCustomization = new VfModule();
4776                 return Arrays.asList(vnfResourceCustomization);
4777             }
4778         };
4779
4780         mockedSession = new MockUp<Session>() {
4781             @Mock
4782             public Query createQuery(String hql) {
4783                 assertTrue(hql.contains("FROM VfModule"));
4784                 return mockUpQuery.getMockInstance();
4785             }
4786         };
4787
4788         mockCd = new MockUp<CatalogDatabase>() {
4789             @Mock
4790             private Session getSession() {
4791                 return mockedSession.getMockInstance();
4792             }
4793         };
4794         List<VfModule> allVfModules = cd.getAllVfModules();
4795         assertFalse(allVfModules.isEmpty());
4796     }
4797     @Test
4798     public void getAllVfModuleCustomizationsTest(){
4799         mockUpQuery = new MockUp<Query>() {
4800
4801             @Mock
4802             public List<VfModuleCustomization> list() {
4803                 VfModuleCustomization vnfResourceCustomization = new VfModuleCustomization();
4804                 return Arrays.asList(vnfResourceCustomization);
4805             }
4806         };
4807
4808         mockedSession = new MockUp<Session>() {
4809             @Mock
4810             public Query createQuery(String hql) {
4811                 assertTrue(hql.contains("FROM VfModuleCustomization"));
4812                 return mockUpQuery.getMockInstance();
4813             }
4814         };
4815
4816         mockCd = new MockUp<CatalogDatabase>() {
4817             @Mock
4818             private Session getSession() {
4819                 return mockedSession.getMockInstance();
4820             }
4821         };
4822         List<VfModuleCustomization> allVfModuleCustomizations = cd.getAllVfModuleCustomizations();
4823         assertFalse(allVfModuleCustomizations.isEmpty());
4824     }
4825     @Test
4826     public void getAllHeatEnvironmentTest(){
4827         mockUpQuery = new MockUp<Query>() {
4828
4829             @Mock
4830             public List<HeatEnvironment> list() {
4831                 HeatEnvironment vnfResourceCustomization = new HeatEnvironment();
4832                 return Arrays.asList(vnfResourceCustomization);
4833             }
4834         };
4835
4836         mockedSession = new MockUp<Session>() {
4837             @Mock
4838             public Query createQuery(String hql) {
4839                 assertTrue(hql.contains("FROM HeatEnvironment"));
4840                 return mockUpQuery.getMockInstance();
4841             }
4842         };
4843
4844         mockCd = new MockUp<CatalogDatabase>() {
4845             @Mock
4846             private Session getSession() {
4847                 return mockedSession.getMockInstance();
4848             }
4849         };
4850         List<HeatEnvironment> allHeatEnvironment = cd.getAllHeatEnvironment();
4851         assertFalse(allHeatEnvironment.isEmpty());
4852     }
4853     @Test
4854     public void getHeatEnvironment2Test(){
4855         thrown.expect(Exception.class);
4856         cd.getHeatEnvironment(4993493);
4857     }
4858     @Test
4859     public void getNestedTemplatesTest(){
4860         thrown.expect(Exception.class);
4861         cd.getNestedTemplates(4993493);
4862     }
4863     @Test
4864     public void getNestedTemplates2Test(){
4865         thrown.expect(Exception.class);
4866         cd.getNestedTemplates("4993493");
4867     }
4868     @Test
4869     public void getHeatFilesTest(){
4870         thrown.expect(Exception.class);
4871         cd.getHeatFiles(4993493);
4872     }
4873     @Test
4874     public void getVfModuleToHeatFilesEntryTest(){
4875         thrown.expect(Exception.class);
4876         cd.getVfModuleToHeatFilesEntry("4993493","49959499");
4877     }
4878     @Test
4879     public void getServiceToResourceCustomization(){
4880         thrown.expect(Exception.class);
4881         cd.getServiceToResourceCustomization("4993493","599349","49900");
4882     }
4883     @Test
4884     public void getHeatFilesForVfModuleTest(){
4885         thrown.expect(Exception.class);
4886         cd.getHeatFilesForVfModule("4993493");
4887     }
4888     @Test
4889     public void getHeatTemplateTest(){
4890         thrown.expect(Exception.class);
4891         cd.getHeatTemplate("4993493","test","heat");
4892     }
4893
4894     @Test
4895     public void saveHeatTemplateTest(){
4896         HeatTemplate heat = new HeatTemplate();
4897         Set <HeatTemplateParam> paramSet = new HashSet<>();
4898         thrown.expect(Exception.class);
4899         cd.saveHeatTemplate(heat,paramSet);
4900     }
4901     @Test
4902     public void getHeatEnvironmentTest(){
4903
4904         mockUpQuery = new MockUp<Query>() {
4905
4906             @Mock
4907             public Object uniqueResult() throws Exception {
4908                 return null;
4909             }
4910         };
4911
4912         mockedSession = new MockUp<Session>() {
4913             @Mock
4914             public Query createQuery(String hql) {
4915                 return mockUpQuery.getMockInstance();
4916             }
4917         };
4918
4919         mockCd = new MockUp<CatalogDatabase>() {
4920             @Mock
4921             private Session getSession() {
4922                 return mockedSession.getMockInstance();
4923             }
4924         };
4925         assertEquals(cd.getHeatEnvironment("4993493","test","heat"), null);
4926     }
4927     @Test
4928     public void getHeatEnvironment3Test(){
4929         thrown.expect(Exception.class);
4930         cd.getHeatEnvironment("4993493","test");
4931     }
4932     @Test
4933     public void saveHeatEnvironmentTest(){
4934         HeatEnvironment en = new HeatEnvironment();
4935         thrown.expect(Exception.class);
4936         cd.saveHeatEnvironment(en);
4937     }
4938     @Test
4939     public void saveHeatTemplate2Test(){
4940         HeatTemplate heat = new HeatTemplate();
4941         thrown.expect(Exception.class);
4942         cd.saveHeatTemplate(heat);
4943     }
4944     @Test
4945     public void saveHeatFileTest(){
4946         HeatFiles hf = new HeatFiles();
4947         thrown.expect(Exception.class);
4948         cd.saveHeatFile(hf);
4949     }
4950     @Test
4951     public void saveVnfRecipeTest(){
4952         VnfRecipe vr = new VnfRecipe();
4953         thrown.expect(Exception.class);
4954         cd.saveVnfRecipe(vr);
4955     }
4956     @Test
4957     public void saveVnfComponentsRecipe(){
4958         VnfComponentsRecipe vr = new VnfComponentsRecipe();
4959         thrown.expect(Exception.class);
4960         cd.saveVnfComponentsRecipe(vr);
4961     }
4962     @Test
4963     public void saveOrUpdateVnfResourceTest(){
4964         VnfResource vr = new VnfResource();
4965         thrown.expect(Exception.class);
4966         cd.saveOrUpdateVnfResource(vr);
4967     }
4968     @Test
4969     public void saveVnfResourceCustomizationTest(){
4970         VnfResourceCustomization vr = new VnfResourceCustomization();
4971         thrown.expect(Exception.class);
4972         cd.saveVnfResourceCustomization(vr);
4973     }
4974     @Test
4975     public void saveAllottedResourceCustomizationTest(){
4976         AllottedResourceCustomization arc = new AllottedResourceCustomization();
4977         thrown.expect(Exception.class);
4978         cd.saveAllottedResourceCustomization(arc);
4979     }
4980     @Test
4981     public void saveAllottedResourceTest(){
4982         AllottedResource ar = new AllottedResource();
4983         thrown.expect(Exception.class);
4984         cd.saveAllottedResource(ar);
4985     }
4986     @Test
4987     public void saveNetworkResourceTest() throws RecordNotFoundException {
4988         NetworkResource nr = new NetworkResource();
4989         thrown.expect(Exception.class);
4990         cd.saveNetworkResource(nr);
4991     }
4992     @Test
4993     public void saveToscaCsarTest()throws RecordNotFoundException {
4994         ToscaCsar ts = new ToscaCsar();
4995         thrown.expect(Exception.class);
4996         cd.saveToscaCsar(ts);
4997     }
4998     @Test
4999     public void getToscaCsar(){
5000         thrown.expect(Exception.class);
5001         cd.getToscaCsar("4993493");
5002     }
5003     @Test
5004     public void saveTempNetworkHeatTemplateLookupTest(){
5005         TempNetworkHeatTemplateLookup t = new TempNetworkHeatTemplateLookup();
5006         thrown.expect(Exception.class);
5007         cd.saveTempNetworkHeatTemplateLookup(t);
5008     }
5009     @Test
5010     public void saveVnfResourceToVfModuleCustomizationTest() throws RecordNotFoundException {
5011         VnfResourceCustomization v =new VnfResourceCustomization();
5012         VfModuleCustomization vm = new VfModuleCustomization();
5013         thrown.expect(Exception.class);
5014         cd.saveVnfResourceToVfModuleCustomization(v, vm);
5015     }
5016     @Test
5017     public void saveNetworkResourceCustomizationTest() throws RecordNotFoundException {
5018         NetworkResourceCustomization nrc = new NetworkResourceCustomization();
5019         thrown.expect(Exception.class);
5020         cd.saveNetworkResourceCustomization(nrc);
5021     }
5022
5023     @Test
5024     public void saveServiceToNetworksTest(){
5025         AllottedResource ar = new AllottedResource();
5026         thrown.expect(Exception.class);
5027         cd.saveAllottedResource(ar);
5028     }
5029     @Test
5030     public void saveServiceToResourceCustomizationTest(){
5031         ServiceToResourceCustomization ar = new ServiceToResourceCustomization();
5032         thrown.expect(Exception.class);
5033         cd.saveServiceToResourceCustomization(ar);
5034     }
5035     @Test
5036     public void saveServiceTest(){
5037         Service ar = new Service();
5038         thrown.expect(Exception.class);
5039         cd.saveService(ar);
5040     }
5041     @Test
5042     public void saveOrUpdateVfModuleTest(){
5043         VfModule ar = new VfModule();
5044         thrown.expect(Exception.class);
5045         cd.saveOrUpdateVfModule(ar);
5046     }
5047     @Test
5048     public void saveOrUpdateVfModuleCustomizationTest(){
5049         VfModuleCustomization ar = new VfModuleCustomization();
5050         thrown.expect(Exception.class);
5051         cd.saveOrUpdateVfModuleCustomization(ar);
5052     }
5053
5054     @Test
5055     public void getNestedHeatTemplateTest(){
5056         thrown.expect(Exception.class);
5057         cd.getNestedHeatTemplate(101,201);
5058     }
5059     @Test
5060     public void getNestedHeatTemplate2Test(){
5061         thrown.expect(Exception.class);
5062         cd.getNestedHeatTemplate("1002","1002");
5063     }
5064     @Test
5065     public void saveNestedHeatTemplateTest(){
5066         HeatTemplate ar = new HeatTemplate();
5067         thrown.expect(Exception.class);
5068         cd.saveNestedHeatTemplate("1001",ar,"test");
5069     }
5070     @Test
5071     public void getHeatFiles2Test(){
5072         VfModuleCustomization ar = new VfModuleCustomization();
5073         thrown.expect(Exception.class);
5074         cd.getHeatFiles(101,"test","1001","v2");
5075     }
5076     @Test
5077     public void getHeatFiles3Test(){
5078         VfModuleCustomization ar = new VfModuleCustomization();
5079         thrown.expect(Exception.class);
5080         cd.getHeatFiles("200192");
5081     }
5082     @Test
5083     public void saveHeatFilesTest(){
5084         HeatFiles ar = new HeatFiles();
5085         thrown.expect(Exception.class);
5086         cd.saveHeatFiles(ar);
5087     }
5088     @Test
5089     public void saveVfModuleToHeatFilesTest(){
5090         HeatFiles ar = new HeatFiles();
5091         thrown.expect(Exception.class);
5092         cd.saveVfModuleToHeatFiles("3772893",ar);
5093     }
5094     @Test
5095     public void getNetworkResourceByModelUuidTest(){
5096
5097         cd.getNetworkResourceByModelUuid("3899291");
5098     }
5099     @Test
5100     public void getNetworkRecipeTest(){
5101         thrown.expect(Exception.class);
5102         cd.getNetworkRecipe("test","test1","test2");
5103     }
5104     @Test
5105     public void getNetworkRecipe2Test(){
5106         mockUpQuery = new MockUp<Query>() {
5107             @Mock
5108             public List<NetworkRecipe> list() {
5109                 NetworkRecipe heatTemplate = new NetworkRecipe();
5110                 return Arrays.asList(heatTemplate);
5111             }
5112         };
5113
5114         mockedSession = new MockUp<Session>() {
5115             @Mock
5116             public Query createQuery(String hql) {
5117                 return mockUpQuery.getMockInstance();
5118             }
5119         };
5120
5121         mockCd = new MockUp<CatalogDatabase>() {
5122             @Mock
5123             private Session getSession() {
5124                 return mockedSession.getMockInstance();
5125             }
5126         };
5127         NetworkRecipe networkRecipe = cd.getNetworkRecipe("test","test1");assertNotNull(networkRecipe);
5128         assertNotNull(networkRecipe);
5129
5130     }
5131     @Test
5132     public void getNetworkResourceByModelCustUuidTest(){
5133
5134         cd.getNetworkResourceByModelCustUuid("test");
5135     }
5136
5137     @Test
5138     public void getVnfComponentsRecipeByVfModuleModelUUIdTest(){
5139         mockUpQuery = new MockUp<Query>() {
5140             @Mock
5141             public List<VnfComponentsRecipe> list() {
5142                 VnfComponentsRecipe heatTemplate = new VnfComponentsRecipe();
5143                 return Arrays.asList(heatTemplate);
5144             }
5145         };
5146
5147         mockedSession = new MockUp<Session>() {
5148             @Mock
5149             public Query createQuery(String hql) {
5150                 return mockUpQuery.getMockInstance();
5151             }
5152         };
5153
5154         mockCd = new MockUp<CatalogDatabase>() {
5155             @Mock
5156             private Session getSession() {
5157                 return mockedSession.getMockInstance();
5158             }
5159         };
5160         VnfComponentsRecipe vnfComponentsRecipeByVfModuleModelUUId = cd.getVnfComponentsRecipeByVfModuleModelUUId("test1", "test2", "test3");
5161         assertNotNull(vnfComponentsRecipeByVfModuleModelUUId);
5162     }
5163     @Test
5164     public void getVnfComponentRecipesTest(){
5165         mockUpQuery = new MockUp<Query>() {
5166             @Mock
5167             public List<VnfComponentsRecipe> list() {
5168                 VnfComponentsRecipe heatTemplate = new VnfComponentsRecipe();
5169                 return Arrays.asList(heatTemplate);
5170             }
5171         };
5172
5173         mockedSession = new MockUp<Session>() {
5174             @Mock
5175             public Query createQuery(String hql) {
5176                 return mockUpQuery.getMockInstance();
5177             }
5178         };
5179
5180         mockCd = new MockUp<CatalogDatabase>() {
5181             @Mock
5182             private Session getSession() {
5183                 return mockedSession.getMockInstance();
5184             }
5185         };
5186         List<VnfComponentsRecipe> test = cd.getVnfComponentRecipes("test");
5187         assertNotNull(test);
5188         assertFalse(test.isEmpty());
5189     }
5190     @Test
5191     public void saveOrUpdateVnfComponentTest(){
5192         VnfComponent ar = new VnfComponent();
5193         thrown.expect(Exception.class);
5194         cd.saveOrUpdateVnfComponent(ar);
5195     }
5196
5197     @Test
5198     public void getVfModule2Test(){
5199         mockUpQuery = new MockUp<Query>() {
5200             @Mock
5201             public List<VfModule> list() {
5202                 VfModule heatTemplate = new VfModule();
5203                 return Arrays.asList(heatTemplate);
5204             }
5205         };
5206
5207         mockedSession = new MockUp<Session>() {
5208             @Mock
5209             public Query createQuery(String hql) {
5210                 return mockUpQuery.getMockInstance();
5211             }
5212         };
5213
5214         mockCd = new MockUp<CatalogDatabase>() {
5215             @Mock
5216             private Session getSession() {
5217                 return mockedSession.getMockInstance();
5218             }
5219         };
5220         VfModule test = cd.getVfModule("test");
5221         assertNotNull(test);
5222     }
5223     @Test
5224     public void getVfModuleByModelUUIDTest(){
5225         mockUpQuery = new MockUp<Query>() {
5226             @Mock
5227             public List<VfModule> list() {
5228                 VfModule heatTemplate = new VfModule();
5229                 return Arrays.asList(heatTemplate);
5230             }
5231         };
5232
5233         mockedSession = new MockUp<Session>() {
5234             @Mock
5235             public Query createQuery(String hql) {
5236                 return mockUpQuery.getMockInstance();
5237             }
5238         };
5239
5240         mockCd = new MockUp<CatalogDatabase>() {
5241             @Mock
5242             private Session getSession() {
5243                 return mockedSession.getMockInstance();
5244             }
5245         };
5246
5247         VfModule test = cd.getVfModuleByModelUUID("test");
5248         assertNotNull(test);
5249     }
5250     @Test
5251     public void getServiceRecipeByModelUUIDTest(){
5252         mockUpQuery = new MockUp<Query>() {
5253             @Mock
5254             public List<ServiceRecipe> list() {
5255                 ServiceRecipe heatTemplate = new ServiceRecipe();
5256                 return Arrays.asList(heatTemplate);
5257             }
5258         };
5259
5260         mockedSession = new MockUp<Session>() {
5261             @Mock
5262             public Query createQuery(String hql) {
5263                 return mockUpQuery.getMockInstance();
5264             }
5265         };
5266
5267         mockCd = new MockUp<CatalogDatabase>() {
5268             @Mock
5269             private Session getSession() {
5270                 return mockedSession.getMockInstance();
5271             }
5272         };
5273
5274         Assert.assertNotNull(cd.getServiceRecipeByModelUUID("test1", "test2"));
5275     }
5276     @Test
5277     public void getModelRecipeTest(){
5278         mockUpQuery = new MockUp<Query>() {
5279             @Mock
5280             public List<Object> list() {
5281                 return new ArrayList();
5282             }
5283         };
5284
5285         mockedSession = new MockUp<Session>() {
5286             @Mock
5287             public Query createQuery(String hql) {
5288                 return mockUpQuery.getMockInstance();
5289             }
5290         };
5291
5292         mockCd = new MockUp<CatalogDatabase>() {
5293             @Mock
5294             private Session getSession() {
5295                 return mockedSession.getMockInstance();
5296             }
5297         };
5298
5299         Assert.assertNull(cd.getModelRecipe("test1", "test2", "test3"));
5300     }
5301     @Test
5302     @Ignore
5303     public void healthCheck(){
5304         mockUpQuery = new MockUp<Query>() {
5305             @Mock
5306             public List<HeatTemplate> list() {
5307                 HeatTemplate heatTemplate = new HeatTemplate();
5308                 return Arrays.asList(heatTemplate);
5309             }
5310         };
5311
5312         mockedSession = new MockUp<Session>() {
5313             @Mock
5314             public Query createSQLQuery(String hql) {
5315                 return mockUpQuery.getMockInstance();
5316             }
5317
5318         };
5319
5320         mockCd = new MockUp<CatalogDatabase>() {
5321             @Mock
5322             private Session getSession() {
5323                 return mockedSession.getMockInstance();
5324             }
5325         };
5326         assertNotNull(cd.healthCheck());
5327     }
5328     @Test
5329     public void executeQuerySingleRow(){
5330         VnfComponent ar = new VnfComponent();
5331         HashMap<String, String> variables = new HashMap<>();
5332         thrown.expect(Exception.class);
5333         cd.executeQuerySingleRow("tets",variables,false);
5334     }
5335
5336     @Test
5337     public void executeQueryMultipleRows(){
5338         HashMap<String, String> variables = new HashMap<>();
5339
5340         mockUpQuery = new MockUp<Query>() {
5341             @Mock
5342             public List<HeatTemplate> list() {
5343                 HeatTemplate heatTemplate = new HeatTemplate();
5344                 return Arrays.asList(heatTemplate);
5345             }
5346         };
5347
5348         mockedSession = new MockUp<Session>() {
5349             @Mock
5350             public Query createQuery(String hql) {
5351                 return mockUpQuery.getMockInstance();
5352             }
5353         };
5354
5355         mockCd = new MockUp<CatalogDatabase>() {
5356             @Mock
5357             private Session getSession() {
5358                 return mockedSession.getMockInstance();
5359             }
5360         };
5361
5362
5363         List<Object> select = cd.executeQueryMultipleRows("select", variables, false);
5364         assertFalse(select.isEmpty());
5365     }
5366
5367     @Test
5368     public void getArRecipeByNameVersion(){
5369         mockUpQuery = new MockUp<Query>() {
5370             @Mock
5371             public List<ArRecipe> list() {
5372                 ArRecipe arRecipe = new ArRecipe();
5373                 return Arrays.asList(arRecipe);
5374             }
5375         };
5376
5377         mockedSession = new MockUp<Session>() {
5378             @Mock
5379             public Query createQuery(String hql) {
5380                 return mockUpQuery.getMockInstance();
5381             }
5382         };
5383
5384         mockCd = new MockUp<CatalogDatabase>() {
5385             @Mock
5386             private Session getSession() {
5387                 return mockedSession.getMockInstance();
5388             }
5389         };
5390         assertNotNull(cd.getArRecipeByNameVersion("select","variables","String"));
5391     }
5392     @Test
5393     public void getVnfComponentsRecipe(){
5394         mockUpQuery = new MockUp<Query>() {
5395             @Mock
5396             public List<VnfComponentsRecipe> list() {
5397                 VnfComponentsRecipe heatTemplate = new VnfComponentsRecipe();
5398                 return Arrays.asList(heatTemplate);
5399             }
5400         };
5401
5402         mockedSession = new MockUp<Session>() {
5403             @Mock
5404             public Query createQuery(String hql) {
5405                 return mockUpQuery.getMockInstance();
5406             }
5407         };
5408
5409         mockCd = new MockUp<CatalogDatabase>() {
5410             @Mock
5411             private Session getSession() {
5412                 return mockedSession.getMockInstance();
5413             }
5414         };
5415         assertNotNull(cd.getVnfComponentsRecipe("vnfType","vnfComponentType","action","serviceType"));
5416     }
5417     @Test
5418     public void getNetworkRecipeByNameVersion(){
5419         mockUpQuery = new MockUp<Query>() {
5420             @Mock
5421             public List<NetworkRecipe> list() {
5422                 NetworkRecipe heatTemplate = new NetworkRecipe();
5423                 return Arrays.asList(heatTemplate);
5424             }
5425         };
5426
5427         mockedSession = new MockUp<Session>() {
5428             @Mock
5429             public Query createQuery(String hql) {
5430                 return mockUpQuery.getMockInstance();
5431             }
5432         };
5433
5434         mockCd = new MockUp<CatalogDatabase>() {
5435             @Mock
5436             private Session getSession() {
5437                 return mockedSession.getMockInstance();
5438             }
5439         };
5440         assertNotNull(cd.getNetworkRecipeByNameVersion("modelName","modelVersion","action"));
5441     }
5442     @Test
5443     public void saveOrUpdateVfModuleCustomization(){
5444         mockUpQuery = new MockUp<Query>() {
5445             @Mock
5446             public List<NetworkRecipe> list() {
5447                 NetworkRecipe heatTemplate = new NetworkRecipe();
5448                 return Arrays.asList(heatTemplate);
5449             }
5450         };
5451
5452         mockedSession = new MockUp<Session>() {
5453             @Mock
5454             public Query createQuery(String hql) {
5455                 return mockUpQuery.getMockInstance();
5456             }
5457         };
5458
5459         mockCd = new MockUp<CatalogDatabase>() {
5460             @Mock
5461             private Session getSession() {
5462                 return mockedSession.getMockInstance();
5463             }
5464         };
5465
5466         VfModuleCustomization vfModuleCustomization = new VfModuleCustomization();
5467         vfModuleCustomization.setHeatEnvironmentArtifactUuid("HeatEnvironmentArtifactUuid");
5468         vfModuleCustomization.setVolEnvironmentArtifactUuid("VolEnvironmentArtifactUuid");
5469         vfModuleCustomization.setVfModuleModelUuid("VfModuleModelUuid");
5470         vfModuleCustomization.setModelCustomizationUuid("ModelCustomizationUuid");
5471         cd.saveOrUpdateVfModuleCustomization(vfModuleCustomization);
5472     }
5473     @Test
5474     public void saveServiceToNetworks(){
5475         mockUpQuery = new MockUp<Query>() {
5476
5477             @Mock
5478             public List<Service> list() {
5479                 Service service = new Service();
5480                 service.setModelUUID("123-uuid");
5481                 return Arrays.asList(service);
5482             }
5483         };
5484
5485         mockedSession = new MockUp<Session>() {
5486             @Mock
5487             public Query createQuery(String hql) {
5488                 return mockUpQuery.getMockInstance();
5489             }
5490         };
5491
5492         mockCd = new MockUp<CatalogDatabase>() {
5493             @Mock
5494             private Session getSession() {
5495                 return mockedSession.getMockInstance();
5496             }
5497         };
5498
5499         ServiceToNetworks serviceToNetworks = new ServiceToNetworks();
5500         cd.saveServiceToNetworks(serviceToNetworks);
5501     }
5502     @Test
5503     public void saveVfModuleToHeatFiles() {
5504         mockUpQuery = new MockUp<Query>() {
5505
5506             @Mock
5507             public List<Service> list() {
5508                 Service service = new Service();
5509                 service.setModelUUID("123-uuid");
5510                 return Arrays.asList(service);
5511             }
5512         };
5513
5514         mockedSession = new MockUp<Session>() {
5515             @Mock
5516             public Query createQuery(String hql) {
5517                 return mockUpQuery.getMockInstance();
5518             }
5519         };
5520
5521         mockCd = new MockUp<CatalogDatabase>() {
5522             @Mock
5523             private Session getSession() {
5524                 return mockedSession.getMockInstance();
5525             }
5526         };
5527
5528         VfModuleToHeatFiles vfModuleToHeatFiles = new VfModuleToHeatFiles();
5529
5530         cd.saveVfModuleToHeatFiles(vfModuleToHeatFiles);
5531     }
5532     @Test
5533     public void saveTempNetworkHeatTemplateLookup() {
5534         mockUpQuery = new MockUp<Query>() {
5535
5536             @Mock
5537             public List<Service> list() {
5538                 Service service = new Service();
5539                 service.setModelUUID("123-uuid");
5540                 return Arrays.asList(service);
5541             }
5542         };
5543
5544         mockedSession = new MockUp<Session>() {
5545             @Mock
5546             public Query createQuery(String hql) {
5547                 return mockUpQuery.getMockInstance();
5548             }
5549         };
5550
5551         mockCd = new MockUp<CatalogDatabase>() {
5552             @Mock
5553             private Session getSession() {
5554                 return mockedSession.getMockInstance();
5555             }
5556         };
5557
5558         TempNetworkHeatTemplateLookup tempNetworkHeatTemplateLookup = new TempNetworkHeatTemplateLookup();
5559
5560         cd.saveTempNetworkHeatTemplateLookup(tempNetworkHeatTemplateLookup);
5561     }
5562     @Test
5563     public void getToscaCsarByServiceModelUUID() {
5564         mockUpQuery = new MockUp<Query>() {
5565
5566             @Mock
5567             public List<Service> list() {
5568                 Service service = new Service();
5569                 service.setModelUUID("123-uuid");
5570                 return Arrays.asList(service);
5571             }
5572         };
5573
5574         mockedSession = new MockUp<Session>() {
5575             @Mock
5576             public Query createQuery(String hql) {
5577                 return mockUpQuery.getMockInstance();
5578             }
5579         };
5580
5581         mockCd = new MockUp<CatalogDatabase>() {
5582             @Mock
5583             private Session getSession() {
5584                 return mockedSession.getMockInstance();
5585             }
5586         };
5587
5588
5589         assertNull(cd.getToscaCsarByServiceModelUUID("uuid-123"));
5590         cd.close();
5591     }
5592     @Test
5593     public void getVnfRecipeByNameVersion(){
5594         mockUpQuery = new MockUp<Query>() {
5595                 String version = null;
5596
5597                 @Mock
5598                 public Query setParameter(String name, Object val) {
5599                         if (name.equals("version")) version = (String)val;
5600                         return this.getMockInstance();
5601                 }
5602
5603             @Mock
5604             public List<VnfRecipe> list() {
5605                 if ("nil".equals(version)) return new ArrayList<VnfRecipe>();
5606
5607                 VnfRecipe vnfRecipe = new VnfRecipe();
5608                 vnfRecipe.setVersion(version);
5609                 return Arrays.asList(vnfRecipe);
5610             }
5611         };
5612
5613         mockedSession = new MockUp<Session>() {
5614             @Mock
5615             public Query createQuery(String hql) {
5616                 return mockUpQuery.getMockInstance();
5617             }
5618         };
5619
5620         mockCd = new MockUp<CatalogDatabase>() {
5621             @Mock
5622             private Session getSession() {
5623                 return mockedSession.getMockInstance();
5624             }
5625         };
5626
5627         VnfRecipe vf = cd.getVnfRecipeByNameVersion("modelName","modelVersion","action");
5628         assertEquals("modelVersion", vf.getVersion());
5629
5630         vf = cd.getVnfRecipeByNameVersion("modelName","nil","action");
5631         assertNull(vf);
5632     }
5633
5634     @Test
5635     public void getVnfRecipeByModuleUuid(){
5636         mockUpQuery = new MockUp<Query>() {
5637
5638             @Mock
5639             public List<VnfRecipe> list() {
5640                 VnfRecipe vnfRecipe = new VnfRecipe();
5641                 return Arrays.asList(vnfRecipe);
5642             }
5643         };
5644
5645         mockedSession = new MockUp<Session>() {
5646             @Mock
5647             public Query createQuery(String hql) {
5648                 return mockUpQuery.getMockInstance();
5649             }
5650         };
5651
5652         mockCd = new MockUp<CatalogDatabase>() {
5653             @Mock
5654             private Session getSession() {
5655                 return mockedSession.getMockInstance();
5656             }
5657         };
5658         assertNull(cd.getVnfRecipeByModuleUuid("vnfModelUuid","action"));
5659     }
5660
5661     @Test
5662     public void getVfModuleType(){
5663         mockUpQuery = new MockUp<Query>() {
5664                 String version = null;
5665
5666                 @Mock
5667                 public Query setParameter(String name, Object val) {
5668                         if (name.equals("version")) version = (String)val;
5669                         return this.getMockInstance();
5670                 }
5671
5672                 @Mock
5673                 public Object uniqueResult() {
5674                         if ("nil".equals(version)) return null;
5675                         if ("multi".equals(version)) throw new org.hibernate.NonUniqueResultException(2);
5676                         if ("he".equals(version)) throw new org.hibernate.HibernateException("test case");
5677                         if ("npe".equals(version)) throw new NullPointerException();
5678
5679                         VfModule vfModule = new VfModule();
5680                         vfModule.setVersion(version);
5681                         return vfModule;
5682                 }
5683         };
5684
5685         mockedSession = new MockUp<Session>() {
5686                 @Mock
5687                 public Query createQuery(String hql) {
5688                         return mockUpQuery.getMockInstance();
5689                 }
5690         };
5691
5692         mockCd = new MockUp<CatalogDatabase>() {
5693                 @Mock
5694                 private Session getSession() {
5695                         return mockedSession.getMockInstance();
5696                 }
5697         };
5698
5699         VfModule vm = cd.getVfModuleType("type","version");
5700         assertEquals("version", vm.getVersion());
5701
5702         vm = cd.getVfModuleType("type", "nil");
5703         assertNull(vm);
5704
5705         try {
5706                 thrown = ExpectedException.none();
5707                 thrown.expect(org.hibernate.NonUniqueResultException.class);
5708                 vm = cd.getVfModuleType("type", "multi");
5709         } catch (org.hibernate.NonUniqueResultException e) {
5710                 // noop
5711         }
5712
5713         try {
5714                 thrown = ExpectedException.none();
5715                 thrown.expect(org.hibernate.HibernateException.class);
5716                 vm = cd.getVfModuleType("type", "he");
5717         } catch (org.hibernate.HibernateException e) {
5718                 // noop
5719         }
5720
5721         try {
5722                 thrown = ExpectedException.none();
5723                 thrown.expect(NullPointerException.class);
5724                 vm = cd.getVfModuleType("type", "npe");
5725         } catch (NullPointerException e) {
5726                 // noop
5727         }
5728
5729     }
5730     @Test
5731     public void getVfModuleByModelInvariantUuidAndModelVersion(){
5732         mockUpQuery = new MockUp<Query>() {
5733                 String version = null;
5734
5735                 @Mock
5736                 public Query setParameter(String name, Object val) {
5737                         if (name.equals("modelVersion")) version = (String)val;
5738                         return this.getMockInstance();
5739                 }
5740
5741                 @Mock
5742                 public Object uniqueResult() {
5743                         if ("nil".equals(version)) return null;
5744                         if ("multi".equals(version)) throw new org.hibernate.NonUniqueResultException(2);
5745                         if ("he".equals(version)) throw new org.hibernate.HibernateException("test case");
5746                         if ("npe".equals(version)) throw new NullPointerException();
5747
5748                         VfModule vfModule = new VfModule();
5749                         vfModule.setVersion(version);
5750                         return vfModule;
5751                 }
5752         };
5753
5754         mockedSession = new MockUp<Session>() {
5755                 @Mock
5756                 public Query createQuery(String hql) {
5757                         return mockUpQuery.getMockInstance();
5758                 }
5759         };
5760
5761         mockCd = new MockUp<CatalogDatabase>() {
5762                 @Mock
5763                 private Session getSession() {
5764                         return mockedSession.getMockInstance();
5765                 }
5766         };
5767
5768         VfModule vm = cd.getVfModuleByModelInvariantUuidAndModelVersion("modelInvariantUuid","modelVersion");
5769         assertEquals("modelVersion", vm.getVersion());
5770
5771         vm = cd.getVfModuleByModelInvariantUuidAndModelVersion("modelInvariantUuid","nil");
5772         assertNull(vm);
5773
5774         try {
5775                 thrown = ExpectedException.none();
5776                 thrown.expect(org.hibernate.NonUniqueResultException.class);
5777                 vm = cd.getVfModuleByModelInvariantUuidAndModelVersion("modelInvariantUuid","multi");
5778         } catch (org.hibernate.NonUniqueResultException e) {
5779                 // noop
5780         }
5781
5782         try {
5783                 thrown = ExpectedException.none();
5784                 thrown.expect(org.hibernate.HibernateException.class);
5785                 vm = cd.getVfModuleByModelInvariantUuidAndModelVersion("modelInvariantUuid","he");
5786         } catch (org.hibernate.HibernateException e) {
5787                 // noop
5788         }
5789
5790         try {
5791                 thrown = ExpectedException.none();
5792                 thrown.expect(NullPointerException.class);
5793                 vm = cd.getVfModuleByModelInvariantUuidAndModelVersion("modelInvariantUuid","npe");
5794         } catch (NullPointerException e) {
5795                 // noop
5796         }
5797
5798     }
5799
5800     @Test
5801     public void getVnfResourceCustomizationByModelCustomizationUuid(){
5802         mockUpQuery = new MockUp<Query>() {
5803                 String modelCustomizationUuid = null;
5804
5805                 @Mock
5806                 public Query setParameter(String name, Object val) {
5807                         if (name.equals("modelCustomizationUuid")) modelCustomizationUuid = (String)val;
5808                         return this.getMockInstance();
5809                 }
5810
5811                 @Mock
5812                 public Object uniqueResult() {
5813                         if ("nil".equals(modelCustomizationUuid)) return null;
5814                         if ("multi".equals(modelCustomizationUuid)) throw new org.hibernate.NonUniqueResultException(2);
5815                         if ("he".equals(modelCustomizationUuid)) throw new org.hibernate.HibernateException("test case");
5816                         if ("npe".equals(modelCustomizationUuid)) throw new NullPointerException();
5817
5818                         VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
5819                         vnfResourceCustomization.setModelCustomizationUuid(modelCustomizationUuid);
5820                 return vnfResourceCustomization;
5821                 }
5822         };
5823
5824         mockedSession = new MockUp<Session>() {
5825             @Mock
5826             public Query createQuery(String hql) {
5827                 return mockUpQuery.getMockInstance();
5828             }
5829         };
5830
5831         mockCd = new MockUp<CatalogDatabase>() {
5832             @Mock
5833             private Session getSession() {
5834                 return mockedSession.getMockInstance();
5835             }
5836
5837             @Mock
5838             public VnfResource getVnfResourceByModelUuid(String modelUuid) {
5839                 VnfResource vr = new VnfResource();
5840                 return vr;
5841             }
5842
5843             @Mock
5844             public ArrayList<VfModuleCustomization> getAllVfModuleCustomizations(String vnfResourceCustomizationMCU) {
5845                 VfModuleCustomization vmc = new VfModuleCustomization();
5846                 ArrayList<VfModuleCustomization> toRet = new ArrayList<VfModuleCustomization>();
5847                 toRet.add(vmc);
5848                 return toRet;
5849             }
5850         };
5851
5852         VnfResourceCustomization vrc = cd.getVnfResourceCustomizationByModelCustomizationUuid("modelCustomizationUuid");
5853         assertEquals("modelCustomizationUuid", vrc.getModelCustomizationUuid());
5854
5855         vrc = cd.getVnfResourceCustomizationByModelCustomizationUuid("nil");
5856         assertNull(vrc);
5857
5858         try {
5859                 thrown = ExpectedException.none();
5860                 thrown.expect(org.hibernate.NonUniqueResultException.class);
5861                 vrc = cd.getVnfResourceCustomizationByModelCustomizationUuid("multi");
5862         } catch (org.hibernate.NonUniqueResultException e) {
5863                 // noop
5864         }
5865
5866         try {
5867                 thrown = ExpectedException.none();
5868                 thrown.expect(org.hibernate.HibernateException.class);
5869                 vrc = cd.getVnfResourceCustomizationByModelCustomizationUuid("he");
5870         } catch (org.hibernate.HibernateException e) {
5871                 // noop
5872         }
5873
5874         try {
5875                 thrown = ExpectedException.none();
5876                 thrown.expect(NullPointerException.class);
5877                 vrc = cd.getVnfResourceCustomizationByModelCustomizationUuid("npe");
5878         } catch (NullPointerException e) {
5879                 // noop
5880         }
5881
5882     }
5883
5884     @Test
5885     public void getVfModuleByModelCustomizationIdAndVersion(){
5886         mockUpQuery = new MockUp<Query>() {
5887
5888             @Mock
5889             public List<VnfRecipe> list() {
5890                 VnfRecipe vnfRecipe = new VnfRecipe();
5891                 return Arrays.asList(vnfRecipe);
5892             }
5893         };
5894
5895         mockedSession = new MockUp<Session>() {
5896             @Mock
5897             public Query createQuery(String hql) {
5898                 return mockUpQuery.getMockInstance();
5899             }
5900         };
5901
5902         mockCd = new MockUp<CatalogDatabase>() {
5903             @Mock
5904             private Session getSession() {
5905                 return mockedSession.getMockInstance();
5906             }
5907         };
5908         assertNull(cd.getVfModuleByModelCustomizationIdAndVersion("modelCustomizationUuid","modelVersionId"));
5909     }
5910     @Test
5911     public void getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId(){
5912         mockUpQuery = new MockUp<Query>() {
5913                 String modelInvariantId = null;
5914
5915                 @Mock
5916                 public Query setParameter(String name, Object val) {
5917                         if (name.equals("modelInvariantId")) modelInvariantId = (String)val;
5918                         return this.getMockInstance();
5919                 }
5920
5921                 @Mock
5922                 public Object uniqueResult() {
5923                         if ("nil".equals(modelInvariantId)) return null;
5924                         if ("multi".equals(modelInvariantId)) throw new org.hibernate.NonUniqueResultException(2);
5925                         if ("he".equals(modelInvariantId)) throw new org.hibernate.HibernateException("test case");
5926                         if ("npe".equals(modelInvariantId)) throw new NullPointerException();
5927
5928                         VfModule vfModule = new VfModule();
5929                         vfModule.setModelInvariantUuid(modelInvariantId);
5930                         return vfModule;
5931                 }
5932         };
5933
5934         mockedSession = new MockUp<Session>() {
5935             @Mock
5936             public Query createQuery(String hql) {
5937                 return mockUpQuery.getMockInstance();
5938             }
5939         };
5940
5941         mockCd = new MockUp<CatalogDatabase>() {
5942             @Mock
5943             private Session getSession() {
5944                 return mockedSession.getMockInstance();
5945             }
5946         };
5947
5948         VfModule vm = cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("modelCustomizationUuid","modelVersion","modelInvariantId");
5949         assertEquals("modelInvariantId", vm.getModelInvariantUuid());
5950
5951         vm = cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("modelCustomizationUuid","modelVersion","nil");
5952         assertNull(vm);
5953
5954         try {
5955                 thrown = ExpectedException.none();
5956                 thrown.expect(org.hibernate.NonUniqueResultException.class);
5957                 vm = cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("modelCustomizationUuid","modelVersion","multi");
5958         } catch (org.hibernate.NonUniqueResultException e) {
5959                 // noop
5960         }
5961
5962         try {
5963                 thrown = ExpectedException.none();
5964                 thrown.expect(org.hibernate.HibernateException.class);
5965                 vm = cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("modelCustomizationUuid","modelVersion","he");
5966         } catch (org.hibernate.HibernateException e) {
5967                 // noop
5968         }
5969
5970         try {
5971                 thrown = ExpectedException.none();
5972                 thrown.expect(NullPointerException.class);
5973                 vm = cd.getVfModuleByModelCustomizationIdModelVersionAndModelInvariantId("modelCustomizationUuid","modelVersion", "npe");
5974         } catch (NullPointerException e) {
5975                 // noop
5976         }
5977
5978     }
5979
5980     @Test
5981     public void getVnfResourceCustomizationByModelInvariantId(){
5982         mockUpQuery = new MockUp<Query>() {
5983                 String modelInvariantId = null;
5984
5985                 @Mock
5986                 public Query setParameter(String name, Object val) {
5987                         if (name.equals("modelInvariantId")) modelInvariantId = (String)val;
5988                         return this.getMockInstance();
5989                 }
5990
5991                 @Mock
5992                 public Object uniqueResult() {
5993                         if ("nil".equals(modelInvariantId)) return null;
5994                         if ("multi".equals(modelInvariantId)) throw new org.hibernate.NonUniqueResultException(2);
5995                         if ("he".equals(modelInvariantId)) throw new org.hibernate.HibernateException("test case");
5996                         if ("npe".equals(modelInvariantId)) throw new NullPointerException();
5997
5998                         VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
5999                         vnfResourceCustomization.setVnfResourceModelUuid(modelInvariantId);
6000                         return vnfResourceCustomization;
6001                 }
6002         };
6003
6004         mockedSession = new MockUp<Session>() {
6005             @Mock
6006             public Query createQuery(String hql) {
6007                 return mockUpQuery.getMockInstance();
6008             }
6009         };
6010
6011         mockCd = new MockUp<CatalogDatabase>() {
6012                 @Mock
6013             public VnfResource getVnfResourceByModelUuid(String modelUuid) {
6014                         return new VnfResource();
6015                 }
6016
6017                 @Mock
6018             public ArrayList<VfModuleCustomization> getAllVfModuleCustomizations(String vnfResourceCustomizationMCU) {
6019                         return new ArrayList<VfModuleCustomization>();
6020                 }
6021
6022             @Mock
6023             private Session getSession() {
6024                 return mockedSession.getMockInstance();
6025             }
6026         };
6027
6028         VnfResourceCustomization vrc = cd.getVnfResourceCustomizationByModelInvariantId("modelInvariantId","modelVersion","modelCustomizationName");
6029         assertEquals("modelInvariantId", vrc.getVnfResourceModelUuid());
6030
6031         vrc = cd.getVnfResourceCustomizationByModelInvariantId("nil","modelVersion","modelCustomizationName");
6032         assertNull(vrc);
6033
6034         try {
6035                 thrown = ExpectedException.none();
6036                 thrown.expect(org.hibernate.NonUniqueResultException.class);
6037                 vrc = cd.getVnfResourceCustomizationByModelInvariantId("multi","modelVersion","modelCustomizationName");
6038         } catch (org.hibernate.NonUniqueResultException e) {
6039                 // noop
6040         }
6041
6042         try {
6043                 thrown = ExpectedException.none();
6044                 thrown.expect(org.hibernate.HibernateException.class);
6045                 vrc = cd.getVnfResourceCustomizationByModelInvariantId("he","modelVersion","modelCustomizationName");
6046         } catch (org.hibernate.HibernateException e) {
6047                 // noop
6048         }
6049
6050         try {
6051                 thrown = ExpectedException.none();
6052                 thrown.expect(NullPointerException.class);
6053                 vrc = cd.getVnfResourceCustomizationByModelInvariantId("npe","modelVersion","modelCustomizationName");
6054         } catch (NullPointerException e) {
6055                 // noop
6056         }
6057     }
6058
6059     @Test
6060     public void getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId(){
6061         mockUpQuery = new MockUp<Query>() {
6062
6063             @Mock
6064             public List<VnfResourceCustomization> list() {
6065                 VnfResourceCustomization vnfResourceCustomization = new VnfResourceCustomization();
6066                 return Arrays.asList(vnfResourceCustomization);
6067             }
6068         };
6069
6070         mockedSession = new MockUp<Session>() {
6071             @Mock
6072             public Query createQuery(String hql) {
6073                 return mockUpQuery.getMockInstance();
6074             }
6075         };
6076
6077         mockCd = new MockUp<CatalogDatabase>() {
6078             @Mock
6079             private Session getSession() {
6080                 return mockedSession.getMockInstance();
6081             }
6082         };
6083         assertNotNull(cd.getVnfResourceCustomizationByVnfModelCustomizationNameAndModelVersionId("modelCustomizationName","modelVersionId"));
6084     }
6085
6086     @Test
6087     public void getNetworkResourceById3Test() {
6088         mockUpQuery = new MockUp<Query>() {
6089                 String modelUuid = null;
6090
6091                 @Mock
6092                 public Query setParameter(String name, Object val) {
6093                         if (name.equals("model_uuid")) modelUuid = (String)val;
6094                         return this.getMockInstance();
6095                 }
6096
6097                 @Mock
6098                 public List<NetworkResource> list() {
6099                         if ("nil".equals(modelUuid)) return null;
6100                         if ("multi".equals(modelUuid)) throw new org.hibernate.NonUniqueResultException(2);
6101                         if ("he".equals(modelUuid)) throw new org.hibernate.HibernateException("test case");
6102                         if ("npe".equals(modelUuid)) throw new NullPointerException();
6103
6104                         NetworkResource networkResource = new NetworkResource();
6105                         networkResource.setModelUUID(modelUuid);
6106                         return Arrays.asList(networkResource);
6107                 }
6108         };
6109
6110         mockedSession = new MockUp<Session>() {
6111                 @Mock
6112                 public Query createQuery(String hql) {
6113                         return mockUpQuery.getMockInstance();
6114                 }
6115         };
6116
6117         mockCd = new MockUp<CatalogDatabase>() {
6118                 @Mock
6119                 private Session getSession() {
6120                         return mockedSession.getMockInstance();
6121                 }
6122         };
6123
6124         NetworkResource nr = cd.getNetworkResourceById("test");
6125         assertEquals("test", nr.getModelUUID());
6126
6127         nr = cd.getNetworkResourceById("nil");
6128         assertNull(nr);
6129
6130         try {
6131                 thrown = ExpectedException.none();
6132                 thrown.expect(org.hibernate.NonUniqueResultException.class);
6133                 nr = cd.getNetworkResourceById("multi");
6134         } catch (org.hibernate.NonUniqueResultException e) {
6135                 // noop
6136         }
6137
6138         try {
6139                 thrown = ExpectedException.none();
6140                 thrown.expect(org.hibernate.HibernateException.class);
6141                 nr = cd.getNetworkResourceById("he");
6142         } catch (org.hibernate.HibernateException e) {
6143                 // noop
6144         }
6145
6146         try {
6147                 thrown = ExpectedException.none();
6148                 thrown.expect(NullPointerException.class);
6149                 nr = cd.getNetworkResourceById("npe");
6150         } catch (NullPointerException e) {
6151                 // noop
6152         }
6153     }
6154
6155 }