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