gerrit.onap Code Review - vnfsdk/refrepo.git/blob

   1 /**
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.vnfsdk.marketplace.resource;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertNotNull;
  21 import static org.junit.Assert.assertNull;
  22
  23 import java.io.BufferedInputStream;
  24 import java.io.ByteArrayInputStream;
  25 import java.io.File;
  26 import java.io.FileInputStream;
  27 import java.io.FileNotFoundException;
  28 import java.io.FileOutputStream;
  29 import java.io.FileWriter;
  30 import java.io.IOException;
  31 import java.io.InputStream;
  32 import java.text.DecimalFormat;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.zip.ZipEntry;
  38 import java.util.zip.ZipOutputStream;
  39
  40 import javax.servlet.ReadListener;
  41 import javax.servlet.ServletInputStream;
  42 import javax.servlet.http.HttpServletRequest;
  43 import javax.ws.rs.core.Response;
  44
  45 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.onap.vnfsdk.marketplace.common.FileUtil;
  49 import org.onap.vnfsdk.marketplace.common.ToolUtil;
  50 import org.onap.vnfsdk.marketplace.db.entity.PackageData;
  51 import org.onap.vnfsdk.marketplace.db.impl.MarketplaceDaoImpl;
  52 import org.onap.vnfsdk.marketplace.db.inf.IMarketplaceDao;
  53 import org.onap.vnfsdk.marketplace.db.resource.PackageManager;
  54 import org.onap.vnfsdk.marketplace.db.util.MarketplaceDbUtil;
  55 import org.onap.vnfsdk.marketplace.db.wrapper.PackageHandler;
  56 import org.onap.vnfsdk.marketplace.entity.CsarPackage;
  57 import org.onap.vnfsdk.marketplace.entity.EnumOperationalState;
  58 import org.onap.vnfsdk.marketplace.entity.EnumType;
  59 import org.onap.vnfsdk.marketplace.entity.EnumUsageState;
  60 import org.onap.vnfsdk.marketplace.entity.VnfPackage;
  61 import org.onap.vnfsdk.marketplace.entity.request.PackageBasicInfo;
  62 import org.onap.vnfsdk.marketplace.entity.response.CsarFileUriResponse;
  63 import org.onap.vnfsdk.marketplace.entity.response.PackageMeta;
  64 import org.onap.vnfsdk.marketplace.entity.response.PackageResponse;
  65 import org.onap.vnfsdk.marketplace.filemanage.http.HttpFileManagerImpl;
  66 import org.onap.vnfsdk.marketplace.msb.MsbDetailsHolder;
  67 import org.onap.vnfsdk.marketplace.msb.MsbServer;
  68 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoardingResult;
  69 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoradingRequest;
  70 import org.onap.vnfsdk.marketplace.onboarding.entity.ResultKey;
  71 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestExceutor;
  72 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestHook;
  73 import org.onap.vnfsdk.marketplace.rest.RestResponse;
  74 import org.onap.vnfsdk.marketplace.rest.RestfulClient;
  75 import org.onap.vnfsdk.marketplace.wrapper.PackageWrapper;
  76 import org.onap.vnfsdk.marketplace.wrapper.PackageWrapperUtil;
  77 import org.open.infc.grpc.Result;
  78 import org.open.infc.grpc.client.OpenRemoteCli;
  79
  80 import mockit.Mock;
  81 import mockit.MockUp;
  82
  83 public class PackageResourceTest {
  84
  85     private PackageResource packageResource = null;
  86
  87     private Response response = null;
  88
  89     private String csarID = "csarid";
  90
  91     private List<PackageData> packageDataList = null;
  92
  93     private PackageData packageData = null;
  94
  95     private FormDataContentDisposition fileDetail = null;
  96
  97     private InputStream inputStream = null;
  98
  99     private String operTypeId = "opertype";
 100
 101     private VnfPackage vnfPackageObj = null;
 102
 103     private CsarPackage csarPackageObj = null;
 104
 105     private PackageBasicInfo pkgBasicInfoObj = null;
 106
 107     private PackageMeta pkgMetaObj = null;
 108
 109     private PackageResponse pkgResponseObj = null;
 110
 111     private CsarFileUriResponse csarFileUriResObj = null;
 112
 113     @Before
 114     public void setUp() {
 115         packageResource = new PackageResource();
 116         vnfPackageObj = new VnfPackage();
 117         csarPackageObj = new CsarPackage();
 118         pkgBasicInfoObj = new PackageBasicInfo();
 119         pkgMetaObj = new PackageMeta();
 120         pkgResponseObj = new PackageResponse();
 121         csarFileUriResObj = new CsarFileUriResponse();
 122     }
 123
 124     @Before
 125     public void createTestFile() {
 126         String filePath = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "Test.txt";
 127         File file = new File(filePath);
 128         try {
 129             file.createNewFile();
 130             FileWriter writer = new FileWriter(file);
 131             writer.write("This is test file.");
 132             writer.close();
 133         } catch(Exception e) {
 134             e.printStackTrace();
 135         }
 136
 137         filePath = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 138         file = new File(filePath);
 139         if(!file.exists()) {
 140             file.mkdirs();
 141         }
 142
 143         StringBuilder sb = new StringBuilder();
 144         sb.append("test data");
 145
 146         filePath = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "temp.zip";
 147         file = new File(filePath);
 148         try {
 149             ZipOutputStream out = new ZipOutputStream(new FileOutputStream(file));
 150             ZipEntry e = new ZipEntry("temp.txt");
 151             out.putNextEntry(e);
 152             byte[] data = sb.toString().getBytes();
 153             out.write(data, 0, data.length);
 154             out.closeEntry();
 155             out.close();
 156         } catch(Exception e) {
 157             e.printStackTrace();
 158         }
 159     }
 160
 161     @Test
 162     public void testQueryPackageListByCond() throws Exception {
 163         new MockUp<MarketplaceDaoImpl>() {
 164
 165             @Mock
 166             public List<PackageData> getPackageDataSubset(Map<String, String> queryParam) {
 167                 return new ArrayList<PackageData>();
 168             }
 169         };
 170         try {
 171             response = PackageWrapper.getInstance().queryPackageListByCond(null, null, null, null, null);
 172         } catch(Exception e) {
 173             e.printStackTrace();
 174         }
 175
 176         assertNotNull(response);
 177         assertEquals(200, response.getStatus());
 178
 179         try {
 180             response = packageResource.queryPackageListByCond(null, null, null, null, null);
 181         } catch(Exception e) {
 182             e.printStackTrace();
 183         }
 184         // assertNull(res5);
 185         // assertEquals(00,res5.getStatus());
 186     }
 187
 188     @Test
 189     public void testQueryPackageById() throws Exception {
 190         new MockUp<MarketplaceDaoImpl>() {
 191
 192             @Mock
 193             public List<PackageData> getPackageData(String csarId) {
 194                 return null;
 195             }
 196
 197         };
 198         new MockUp<MarketplaceDaoImpl>() {
 199
 200             @Mock
 201             public List<PackageData> getPackageData(String csarId) {
 202                 packageDataList = new ArrayList<PackageData>();
 203                 packageData = new PackageData();
 204                 packageData.setCsarId(csarId);
 205                 packageData.setDownloadUri("src\\test\\resources\\clearwater_ns.csar");
 206                 packageData.setName("clearwater_ns.csar");
 207                 packageData.setSize("59,854  bytes");
 208                 packageData.setVersion("v1.0");
 209                 packageData.setProvider("Huawei");
 210                 packageDataList.add(packageData);
 211                 return packageDataList;
 212             }
 213         };
 214
 215         try {
 216             response = PackageWrapper.getInstance().queryPackageById(csarID);
 217         } catch(Exception e) {
 218             e.printStackTrace();
 219         }
 220         assertNotNull(response);
 221         assertEquals(200, response.getStatus());
 222
 223         try {
 224             response = packageResource.queryPackageById(csarID);
 225         } catch(Exception e) {
 226             e.printStackTrace();
 227         }
 228     }
 229
 230     @Test
 231     public void testDelPackageFaiure() {
 232         new MockUp<MarketplaceDaoImpl>() {
 233
 234             @Mock
 235             public List<PackageData> getAllPackageData() {
 236                 return new ArrayList<PackageData>();
 237             }
 238         };
 239
 240         new MockUp<MarketplaceDaoImpl>() {
 241
 242             @Mock
 243             public void deletePackageData(String csarId) {
 244                 return;
 245             }
 246         };
 247
 248         new MockUp<MarketplaceDaoImpl>() {
 249
 250             @Mock
 251             public List<PackageData> getPackageData(String csarId) {
 252                 return new ArrayList<PackageData>();
 253             }
 254         };
 255
 256         try {
 257             response = PackageWrapper.getInstance().delPackage("");
 258         } catch(Exception e5) {
 259             e5.printStackTrace();
 260         }
 261         assertEquals(500, response.getStatus());
 262
 263         try {
 264             response = packageResource.delPackage("");
 265         } catch(Exception e) {
 266             e.printStackTrace();
 267         }
 268
 269         try {
 270             response = PackageWrapper.getInstance().delPackage(null);
 271         } catch(Exception e5) {
 272             e5.printStackTrace();
 273         }
 274
 275         try {
 276             response = packageResource.delPackage(null);
 277         } catch(Exception e) {
 278             e.printStackTrace();
 279         }
 280         assertEquals(500, response.getStatus());
 281     }
 282
 283     @Test
 284     public void testDelPackageSuccess() {
 285         new MockUp<MarketplaceDaoImpl>() {
 286
 287             @Mock
 288             public List<PackageData> getAllPackageData() {
 289                 packageDataList = new ArrayList<PackageData>();
 290                 packageData = new PackageData();
 291                 packageData.setCsarId(csarID);
 292                 packageData.setDownloadUri("src\\test\\resources\\clearwater_ns.csar");
 293                 packageData.setName("clearwater_ns.csar");
 294                 packageData.setSize("59,854  bytes");
 295                 packageData.setVersion("v1.0");
 296                 packageData.setProvider("Huawei");
 297                 packageDataList.add(packageData);
 298                 return packageDataList;
 299             }
 300         };
 301
 302         new MockUp<PackageManager>() {
 303
 304             @Mock
 305             public void deletePackage(String csarId) {
 306                 return;
 307             }
 308         };
 309
 310         new MockUp<HttpFileManagerImpl>() {
 311
 312             @Mock
 313             public boolean delete(String srcPath) {
 314                 return true;
 315             }
 316         };
 317
 318         new MockUp<MarketplaceDaoImpl>() {
 319
 320             @Mock
 321             public List<PackageData> getPackageData(String csarId) {
 322                 packageDataList = new ArrayList<PackageData>();
 323                 packageData = new PackageData();
 324                 packageData.setCsarId(csarID);
 325                 packageData.setDownloadUri("src\\test\\resources\\");
 326                 packageData.setName("clearwater_ns.csar");
 327                 packageData.setSize("59,854  bytes");
 328                 packageData.setVersion("v1.0");
 329                 packageData.setProvider("Huawei");
 330                 packageDataList.add(packageData);
 331                 return packageDataList;
 332             }
 333         };
 334
 335         try {
 336             response = PackageWrapper.getInstance().delPackage("csarid");
 337         } catch(Exception e) {
 338             e.printStackTrace();
 339         }
 340
 341         assertNotNull(response);
 342         assertEquals(200, response.getStatus());
 343
 344         try {
 345             response = packageResource.delPackage("csarid");
 346         } catch(Exception e) {
 347             e.printStackTrace();
 348         }
 349     }
 350
 351     @Test
 352     public void testGetCsarFileUri() {
 353         new MockUp<MarketplaceDaoImpl>() {
 354
 355             @Mock
 356             public List<PackageData> getPackageData(String csarId) {
 357                 packageDataList = new ArrayList<PackageData>();
 358                 packageData = new PackageData();
 359                 packageData.setCsarId(csarId);
 360                 packageData.setDownloadUri("src\\test\\resources\\");
 361                 packageData.setName("clearwater_ns.csar");
 362                 packageData.setSize("59,854  bytes");
 363                 packageData.setVersion("v1.0");
 364                 packageData.setProvider("Huawei");
 365                 packageDataList.add(packageData);
 366                 return packageDataList;
 367             }
 368         };
 369
 370         new MockUp<PackageWrapper>() {
 371
 372             @Mock
 373             Response downloadCsarPackagesById(String csarId) throws FileNotFoundException {
 374                 String fileName =
 375                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "Test.txt";
 376                 InputStream fis = new BufferedInputStream(new FileInputStream(fileName));
 377                 return Response.ok(fis).header("Content-Disposition", "attachment; filename=\"" + fileName + "\"")
 378                         .build();
 379             }
 380         };
 381         response = PackageWrapper.getInstance().getCsarFileUri("csarId");
 382         assertEquals(200, response.getStatus());
 383
 384         try {
 385             response = packageResource.getCsarFileUri("csarId");
 386         } catch(Exception e) {
 387             e.printStackTrace();
 388         }
 389     }
 390
 391     @Test
 392     public void testupdateDwonloadCountSuccess() throws Exception {
 393         final List<PackageData> pkgList = new ArrayList<PackageData>();
 394         PackageData pkgDataObj = new PackageData();
 395         pkgDataObj.setDownloadCount(1);
 396         pkgList.add(pkgDataObj);
 397         new MockUp<MarketplaceDaoImpl>() {
 398
 399             @Mock
 400             public List<PackageData> getPackageData(String csarId) {
 401                 return pkgList;
 402                 // return new ArrayList<PackageData>();
 403             }
 404         };
 405         new MockUp<MarketplaceDaoImpl>() {
 406
 407             @Mock
 408             public void updatePackageData(PackageData oPackageData) {
 409                 return;
 410
 411             }
 412         };
 413         try {
 414             response = PackageWrapper.getInstance().updateDwonloadCount(csarID);
 415         } catch(Exception e5) {
 416             e5.printStackTrace();
 417         }
 418         assertNotNull(response);
 419         assertEquals(200, response.getStatus());
 420
 421         try {
 422             response = packageResource.updateDwonloadCount(csarID);
 423         } catch(Exception e) {
 424             e.printStackTrace();
 425         }
 426     }
 427
 428     @Test
 429     public void testReUploadPackage() {
 430         new MockUp<MarketplaceDaoImpl>() {
 431
 432             @Mock
 433             public List<PackageData> getPackageData(String csarId) {
 434                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 435                 PackageData packageData = new PackageData();
 436                 packageData = new PackageData();
 437                 packageData.setCsarId(csarId);
 438                 packageData.setDownloadUri("src\\test\\resources\\clearwater_ns.csar");
 439                 packageData.setName("clearwater_ns.csar");
 440                 packageData.setSize("59,854  bytes");
 441                 packageData.setVersion("v1.0");
 442                 packageData.setProvider("Huawei");
 443                 packageDataList.add(packageData);
 444                 return packageDataList;
 445             }
 446         };
 447
 448         new MockUp<HttpFileManagerImpl>() {
 449
 450             @Mock
 451             public boolean delete(String srcPath) {
 452                 return true;
 453             }
 454         };
 455
 456         new MockUp<MarketplaceDaoImpl>() {
 457
 458             @Mock
 459             public void deletePackageData(String csarId) {
 460                 return;
 461             }
 462         };
 463
 464         new MockUp<ToolUtil>() {
 465
 466             @Mock
 467             public String getTempDir(String dirName, String fileName) {
 468                 String fileN =
 469                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 470                 return fileN;
 471             }
 472         };
 473
 474         new MockUp<HttpFileManagerImpl>() {
 475
 476             @Mock
 477             public boolean upload(String srcPath, String dstPath) {
 478                 return true;
 479             }
 480         };
 481
 482         new MockUp<PackageWrapperUtil>() {
 483
 484             @Mock
 485             public PackageData getPackageData(PackageMeta meta) {
 486                 PackageData packageData = new PackageData();
 487                 packageData.setCreateTime("25-3-2017 15:26:00");
 488                 packageData.setDeletionPending("deletion");
 489                 packageData.setDownloadUri("downloaduri");
 490                 packageData.setFormat("format");
 491                 packageData.setModifyTime("time");
 492                 packageData.setName("name");
 493                 packageData.setCsarId("csarid");
 494                 packageData.setProvider("huawei");
 495                 String fileSize = "10 mb";
 496                 packageData.setSize(fileSize);
 497                 packageData.setType("type");
 498                 packageData.setVersion("v2.0");
 499                 packageData.setDetails("details");
 500                 packageData.setShortDesc("description");
 501                 packageData.setRemarks("remarks");
 502                 return packageData;
 503             }
 504         };
 505
 506         new MockUp<PackageHandler>() {
 507
 508             @Mock
 509             public PackageData create(PackageData packageData) {
 510                 PackageData packageDataObj = new PackageData();
 511                 packageDataObj.setCreateTime("25-3-2017 15:26:00");
 512                 packageDataObj.setDeletionPending("deletion");
 513                 packageDataObj.setDownloadUri("downloaduri");
 514                 packageDataObj.setFormat("format");
 515                 packageDataObj.setModifyTime("modifytime");
 516                 packageDataObj.setName("name");
 517                 packageDataObj.setCsarId("csarid");
 518                 packageDataObj.setProvider("huawei");
 519                 String fileSize = "10 mb";
 520                 packageDataObj.setSize(fileSize);
 521                 packageDataObj.setType("type");
 522                 packageDataObj.setVersion("v2.0");
 523                 packageDataObj.setDetails("details");
 524                 packageDataObj.setShortDesc("description");
 525                 packageDataObj.setRemarks("remarks");
 526                 return packageDataObj;
 527             }
 528         };
 529
 530         try {
 531             response = PackageWrapper.getInstance().reUploadPackage(null, null, null, null, null);
 532         } catch(Exception e) {
 533             e.printStackTrace();
 534         }
 535         assertEquals(417, response.getStatus());
 536
 537         try {
 538             response = packageResource.reUploadPackage(null, null, null, null, null);
 539         } catch(Exception e) {
 540             e.printStackTrace();
 541         }
 542
 543         try {
 544             fileDetail = FormDataContentDisposition.name("fileName").fileName("clearwater_ns.csar").build();
 545             String fileName = "src" + File.separator + "test" + File.separator + "resources" + File.separator
 546                     + "clearwater_ns.csar";
 547             inputStream = new FileInputStream(fileName);
 548             response = PackageWrapper.getInstance().reUploadPackage("csarID", inputStream, fileDetail, null, null);
 549             // assertEquals( 200, response.getStatus() );
 550         } catch(Exception e) {
 551             e.printStackTrace();
 552         }
 553
 554         try {
 555             response = packageResource.reUploadPackage("csarID", inputStream, null, null, null);
 556         } catch(Exception e) {
 557             e.printStackTrace();
 558         }
 559     }
 560
 561     @Test
 562     public void testgetOperResultByOperTypeIdFailure() throws Exception {
 563         final ResultKey resultKeyObj = new ResultKey();
 564
 565         new MockUp<FunctionTestHook>() {
 566
 567             @Mock
 568             ResultKey getFuncTestResultKey(PackageData packageData) {
 569                 resultKeyObj.setKey("key");
 570                 return resultKeyObj;
 571             }
 572         };
 573         new MockUp<FunctionTestExceutor>() {
 574
 575             @Mock
 576             String getTestResultsByFuncTestKey(String key) {
 577                 return null;
 578             }
 579         };
 580
 581         new MockUp<MarketplaceDaoImpl>() {
 582
 583             @Mock
 584             public List<PackageData> getPackageData(String csarId) {
 585                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 586                 PackageData packageData = new PackageData();
 587                 packageData = new PackageData();
 588                 packageData.setCsarId(csarId);
 589                 packageData.setDownloadUri("src\\test\\resources\\learwater_ns.csar");
 590                 packageData.setName("clearwater_ns.csar");
 591                 packageData.setSize("59,854  bytes");
 592                 packageData.setVersion("v1.0");
 593                 packageData.setProvider("Airtel");
 594                 packageDataList.add(packageData);
 595                 return packageDataList;
 596             }
 597         };
 598
 599         try {
 600             response = PackageWrapper.getInstance().getOperResultByOperTypeId(csarID, operTypeId);
 601         } catch(Exception e5) {
 602             e5.printStackTrace();
 603         }
 604         assertEquals(500, response.getStatus());
 605
 606         try {
 607             response = PackageWrapper.getInstance().getOperResultByOperTypeId("", "");
 608         } catch(Exception e) {
 609             e.printStackTrace();
 610         }
 611         assertEquals(400, response.getStatus());
 612
 613         try {
 614             response = packageResource.getOnBoardingResult(null, null, null);
 615         } catch(Exception e) {
 616             e.printStackTrace();
 617         }
 618     }
 619
 620     @Test
 621     public void testgetOperResultByOperTypeIdSuccess() {
 622         new MockUp<MarketplaceDaoImpl>() {
 623
 624             @Mock
 625             public List<PackageData> getPackageData(String csarId) {
 626                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 627                 PackageData packageData = new PackageData();
 628                 packageData = new PackageData();
 629                 packageData.setCsarId(csarId);
 630                 packageData.setDownloadUri("src\\test\\resources\\learwater_ns.csar");
 631                 packageData.setName("clearwater_ns.csar");
 632                 packageData.setSize("59,854  bytes");
 633                 packageData.setVersion("v1.0");
 634                 packageData.setProvider("Airtel");
 635                 packageDataList.add(packageData);
 636                 return packageDataList;
 637             }
 638         };
 639
 640         new MockUp<ToolUtil>() {
 641
 642             @Mock
 643             public String getTempDir(String dirName, String fileName) {
 644                 String filena =
 645                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 646                 return filena;
 647             }
 648         };
 649         new MockUp<PackageWrapper>() {
 650
 651             @Mock
 652             Response downloadCsarPackagesById(String csarId) throws FileNotFoundException {
 653                 String fileName =
 654                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "Test.txt";
 655                 InputStream fis = new BufferedInputStream(new FileInputStream(fileName));
 656                 return Response.ok(fis).header("Content-Disposition", "attachment; filename=\"" + fileName + "\"")
 657                         .build();
 658             }
 659         };
 660
 661         new MockUp<FunctionTestHook>() {
 662
 663             @Mock
 664             ResultKey getFuncTestResultKey(PackageData packageData) {
 665                 ResultKey resultKey = new ResultKey();
 666                 resultKey.setKey("key");
 667                 return resultKey;
 668             }
 669         };
 670         new MockUp<FunctionTestExceutor>() {
 671
 672             @Mock
 673             String getTestResultsByFuncTestKey(String key) {
 674                 return "key";
 675             }
 676         };
 677
 678         try {
 679             response = PackageWrapper.getInstance().getOperResultByOperTypeId(csarID, operTypeId);
 680         } catch(Exception e) {
 681             e.printStackTrace();
 682         }
 683
 684
 685     }
 686
 687     // @Ignore
 688     @Test
 689     public void testUploadPackage() throws Exception {
 690         InputStream ins = null;
 691         Response result = null;
 692         /*
 693          * Response result1 = null; Response result2 = null; PackageData
 694          * packageData = new PackageData(); packageData = getPackageData();
 695          */
 696
 697         new MockUp<MarketplaceDaoImpl>() {
 698
 699             @Mock
 700             public List<PackageData> getPackageData(String csarId) {
 701                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 702                 PackageData packageData = new PackageData();
 703                 packageData = new PackageData();
 704                 packageData.setCsarId(csarId);
 705                 packageData.setDownloadUri("src\\test\\resources\\");
 706                 packageData.setName("clearwater_ns.csar");
 707                 packageData.setSize("59,854  bytes");
 708                 packageData.setVersion("v1.0");
 709                 packageData.setProvider("Airtel");
 710                 packageDataList.add(packageData);
 711                 return packageDataList;
 712             }
 713
 714             @Mock
 715             public List<PackageData> getPackageDataSubset(Map<String, String> paramsMap) {
 716                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 717
 718                 return packageDataList;
 719             }
 720         };
 721
 722         new MockUp<HttpFileManagerImpl>() {
 723
 724             @Mock
 725             public boolean delete(String srcPath) {
 726                 return true;
 727             }
 728         };
 729
 730         new MockUp<MarketplaceDaoImpl>() {
 731
 732             @Mock
 733             public void deletePackageData(String csarId) {
 734                 return;
 735             }
 736         };
 737
 738         new MockUp<ToolUtil>() {
 739
 740             @Mock
 741             public String getTempDir(String dirName, String fileName) {
 742                 String filena =
 743                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 744                 return filena;
 745             }
 746         };
 747
 748         new MockUp<HttpFileManagerImpl>() {
 749
 750             @Mock
 751             public boolean upload(String srcPath, String dstPath) {
 752                 return false;
 753             }
 754         };
 755
 756         new MockUp<PackageHandler>() {
 757
 758             @Mock
 759             public PackageData create(PackageData packageData) {
 760                 PackageData packageDataObj = new PackageData();
 761                 packageDataObj.setCreateTime("25-3-2017 15:26:00");
 762                 packageDataObj.setDeletionPending("deletion");
 763                 packageDataObj.setDownloadUri("downloaduri");
 764                 packageDataObj.setFormat("format");
 765                 packageDataObj.setModifyTime("modifytime");
 766                 packageDataObj.setName("name");
 767                 packageDataObj.setCsarId("csarid");
 768                 packageDataObj.setProvider("huawei");
 769                 String fileSize = "10 mb";
 770                 packageDataObj.setSize(fileSize);
 771                 packageDataObj.setType("type");
 772                 packageDataObj.setVersion("v2.0");
 773                 packageDataObj.setDetails("details");
 774                 packageDataObj.setShortDesc("description");
 775                 packageDataObj.setRemarks("remarks");
 776                 return packageDataObj;
 777             }
 778         };
 779
 780
 781         new MockUp<OpenRemoteCli>() {
 782
 783             @Mock
 784             public Result run(String host, int port, String reqId, List <String> args) {
 785                 Result result = Result.newBuilder().
 786                         setExitCode(0).
 787                         setOutput("{\"error\":\"SUCCESS\"}").
 788                         build();
 789
 790                 return result;
 791             }
 792         };
 793
 794         FormDataContentDisposition fileDetail =
 795                 FormDataContentDisposition.name("fileName").fileName("clearwater_ns.csar").build();
 796
 797         String filenama =
 798                 "src" + File.separator + "test" + File.separator + "resources" + File.separator + "clearwater_ns.csar";
 799         File packageFile = new File(filenama);
 800
 801         try {
 802             ins = new FileInputStream(packageFile);
 803         } catch(FileNotFoundException e2) {
 804             e2.printStackTrace();
 805         }
 806         if(ins != null) {
 807             try {
 808                 result = PackageWrapper.getInstance().uploadPackage(ins, fileDetail, null, null);
 809                 // PackageWrapper.getInstance().updateValidateStatus(ins);
 810             } catch(Exception e3) {
 811                 e3.printStackTrace();
 812             }
 813         }
 814
 815         assertNotNull(result);
 816         assertEquals(200, result.getStatus());
 817
 818         try {
 819             result = PackageWrapper.getInstance().uploadPackage(null, null, null, null);
 820         } catch(Exception e4) {
 821             e4.printStackTrace();
 822         }
 823
 824         assertEquals(417, result.getStatus());
 825
 826         try {
 827             response = packageResource.uploadPackage(null, null, null, null);
 828         } catch(Exception e) {
 829             e.printStackTrace();
 830         }
 831     }
 832
 833     @Test
 834     public void testUploadPackageFailedOnVtp() throws Exception {
 835         InputStream ins = null;
 836         Response result = null;
 837         /*
 838          * Response result1 = null; Response result2 = null; PackageData
 839          * packageData = new PackageData(); packageData = getPackageData();
 840          */
 841
 842         new MockUp<MarketplaceDaoImpl>() {
 843
 844             @Mock
 845             public List<PackageData> getPackageData(String csarId) {
 846                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 847                 PackageData packageData = new PackageData();
 848                 packageData = new PackageData();
 849                 packageData.setCsarId(csarId);
 850                 packageData.setDownloadUri("src\\test\\resources\\");
 851                 packageData.setName("clearwater_ns.csar");
 852                 packageData.setSize("59,854  bytes");
 853                 packageData.setVersion("v1.0");
 854                 packageData.setProvider("Airtel");
 855                 packageDataList.add(packageData);
 856                 return packageDataList;
 857             }
 858
 859             @Mock
 860             public List<PackageData> getPackageDataSubset(Map<String, String> paramsMap) {
 861                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 862
 863                 return packageDataList;
 864             }
 865         };
 866
 867         new MockUp<HttpFileManagerImpl>() {
 868
 869             @Mock
 870             public boolean delete(String srcPath) {
 871                 return true;
 872             }
 873         };
 874
 875         new MockUp<MarketplaceDaoImpl>() {
 876
 877             @Mock
 878             public void deletePackageData(String csarId) {
 879                 return;
 880             }
 881         };
 882
 883         new MockUp<ToolUtil>() {
 884
 885             @Mock
 886             public String getTempDir(String dirName, String fileName) {
 887                 String filena =
 888                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 889                 return filena;
 890             }
 891         };
 892
 893         new MockUp<HttpFileManagerImpl>() {
 894
 895             @Mock
 896             public boolean upload(String srcPath, String dstPath) {
 897                 return false;
 898             }
 899         };
 900
 901         new MockUp<PackageWrapperUtil>() {
 902
 903             @Mock
 904             public PackageData getPackageData(PackageMeta meta) {
 905                 PackageData packageData = new PackageData();
 906                 packageData.setCreateTime("25-3-2017 15:26:00");
 907                 packageData.setDeletionPending("deletion");
 908                 packageData.setDownloadUri("downloaduri");
 909                 packageData.setFormat("format");
 910                 packageData.setModifyTime("time");
 911                 packageData.setName("name");
 912                 packageData.setCsarId("csarid");
 913                 packageData.setProvider("huawei");
 914                 String fileSize = "10 mb";
 915                 packageData.setSize(fileSize);
 916                 packageData.setType("type");
 917                 packageData.setVersion("v2.0");
 918                 packageData.setDetails("details");
 919                 packageData.setShortDesc("description");
 920                 packageData.setRemarks("remarks");
 921                 return packageData;
 922             }
 923         };
 924
 925         new MockUp<PackageHandler>() {
 926
 927             @Mock
 928             public PackageData create(PackageData packageData) {
 929                 PackageData packageDataObj = new PackageData();
 930                 packageDataObj.setCreateTime("25-3-2017 15:26:00");
 931                 packageDataObj.setDeletionPending("deletion");
 932                 packageDataObj.setDownloadUri("downloaduri");
 933                 packageDataObj.setFormat("format");
 934                 packageDataObj.setModifyTime("modifytime");
 935                 packageDataObj.setName("name");
 936                 packageDataObj.setCsarId("csarid");
 937                 packageDataObj.setProvider("huawei");
 938                 String fileSize = "10 mb";
 939                 packageDataObj.setSize(fileSize);
 940                 packageDataObj.setType("type");
 941                 packageDataObj.setVersion("v2.0");
 942                 packageDataObj.setDetails("details");
 943                 packageDataObj.setShortDesc("description");
 944                 packageDataObj.setRemarks("remarks");
 945                 return packageDataObj;
 946             }
 947         };
 948
 949
 950         new MockUp<OpenRemoteCli>() {
 951
 952             @Mock
 953             public Result run(String host, int port, String reqId, List <String> args) throws Exception {
 954                 throw new Exception();
 955             }
 956         };
 957
 958         FormDataContentDisposition fileDetail =
 959                 FormDataContentDisposition.name("fileName").fileName("clearwater_ns.csar").build();
 960
 961         String filenama =
 962                 "src" + File.separator + "test" + File.separator + "resources" + File.separator + "clearwater_ns.csar";
 963         File packageFile = new File(filenama);
 964
 965         try {
 966             ins = new FileInputStream(packageFile);
 967         } catch(FileNotFoundException e2) {
 968             e2.printStackTrace();
 969         }
 970         if(ins != null) {
 971             try {
 972                 result = PackageWrapper.getInstance().uploadPackage(ins, fileDetail, null, null);
 973                 // PackageWrapper.getInstance().updateValidateStatus(ins);
 974             } catch(Exception e3) {
 975                 e3.printStackTrace();
 976             }
 977         }
 978
 979         assertEquals(200, result.getStatus());
 980     }
 981
 982     @Test
 983     public void testGetOnBoardingStepsSuccess() {
 984         new MockUp<org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil>() {
 985
 986             @Mock
 987             String getAppDeployPath() {
 988                 String path = "src" + File.separator + "main" + File.separator + "resources";
 989                 return path;
 990             }
 991         };
 992
 993         try {
 994             response = PackageWrapper.getInstance().getOnBoardingSteps();
 995         } catch(Exception e) {
 996             e.printStackTrace();
 997         }
 998
 999         assertNotNull(response);
1000
1001         try {
1002             response = packageResource.getOnBoardingSteps();
1003         } catch(Exception e) {
1004             e.printStackTrace();
1005         }
1006     }
1007
1008     @Test
1009     public void testGetOOprStatusSuccess() {
1010         try {
1011             response = packageResource.getOperStatus(null, null);
1012         } catch(Exception e) {
1013             e.printStackTrace();
1014         }
1015     }
1016
1017     @Test
1018     public void testUpdateStatusSuccess() {
1019         MockUp mockReq = new MockUp<HttpServletRequest>() {
1020
1021             @Mock
1022             public ServletInputStream getInputStream() throws IOException {
1023                   ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
1024                           "{\"csar\"=\"VoLTE.csar\"}".getBytes());
1025
1026                   return new ServletInputStream(){
1027                     public int read() throws IOException {
1028                       return byteArrayInputStream.read();
1029                     }
1030
1031                     @Override
1032                     public boolean isFinished() {
1033                         return true;
1034                     }
1035
1036                     @Override
1037                     public boolean isReady() {
1038                         return true;
1039                     }
1040
1041                     @Override
1042                     public void setReadListener(ReadListener arg0) {
1043                     }
1044                   };
1045                 }
1046
1047         };
1048         try {
1049             response = packageResource.updateValidateStatus((HttpServletRequest) mockReq.getMockInstance(), null);
1050         } catch(Exception e) {
1051             e.printStackTrace();
1052         }
1053     }
1054
1055     @Test
1056     public void testGetOnBoardingStepsFailure() {
1057         new MockUp<org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil>() {
1058
1059             @Mock
1060             String getAppDeployPath() {
1061                 String path = "src" + File.separator + "main" + File.separator + "resources" + File.separator
1062                         + "generalconfig";
1063                 return path;
1064             }
1065         };
1066
1067         try {
1068             response = PackageWrapper.getInstance().getOnBoardingSteps();
1069         } catch(Exception e) {
1070             e.printStackTrace();
1071         }
1072         assertEquals(500, response.getStatus());
1073     }
1074
1075     @Test
1076     public void testRestGetClient() {
1077         new MockUp<RestfulClient>() {
1078             @Mock
1079             RestResponse get(String ip, int port, String url) {
1080                 RestResponse restResponse = new RestResponse();
1081                 restResponse.setStatusCode(200);
1082                 restResponse.setResult("success");
1083                 return restResponse;
1084             }
1085         };
1086         String dirPath = "etc//conf//restclient.json";
1087        FileUtil.createDirectory(dirPath);
1088         MsbServer msbServer = new MsbServer();
1089         msbServer.setHost("localhost");
1090         msbServer.setPort("8080");
1091         Map<String, MsbServer> map = new HashMap<>();
1092         map.put("defaultServer", msbServer);
1093         FileUtil.writeJsonDatatoFile(dirPath, map);
1094         assertNotNull(FunctionTestExceutor.getTestResultsByFuncTestKey("GET"));
1095         FileUtil.deleteDirectory("etc");
1096
1097     }
1098
1099     @Test
1100     public void testRestPostClient() {
1101
1102         OnBoradingRequest onBoradFuncTestReq = new OnBoradingRequest();
1103         onBoradFuncTestReq.setPackagePath("src/test/resources/clearwater_ns.csar");
1104         onBoradFuncTestReq.setPackageName("clearwater_ns.csar");
1105         String result = FunctionTestExceutor.execFunctionTest(onBoradFuncTestReq);
1106         assertNull(result);
1107         // assertEquals(200,result);
1108
1109     }
1110
1111     @Test
1112     public void testRestDeleteClient() {
1113         RestResponse rsp = RestfulClient.delete("127.0.0.1", 8987, "TestURL");
1114         assertNotNull(rsp);
1115         if(rsp.getStatusCode() != null)
1116             assertEquals(200, rsp.getStatusCode().intValue());
1117
1118     }
1119
1120     @Test
1121     public void testExec() {
1122
1123         new MockUp<FunctionTestHook>() {
1124
1125             @Mock
1126             String getResultStorePath() {
1127                 return "src/test/resources";
1128
1129             }
1130         };
1131         FunctionTestHook testHookObj = new FunctionTestHook();
1132         OnBoradingRequest onBoradFuncTestReq = new OnBoradingRequest();
1133         onBoradFuncTestReq.setPackagePath("src/test/resources/clearwater_ns.csar");
1134         int res = testHookObj.exec(onBoradFuncTestReq);
1135
1136         assertEquals(res, -1);
1137     }
1138
1139     @Test
1140
1141     public void testwriteJsonDatatoFile() {
1142
1143         String filePath = "src//test//resources//functionTest.json";
1144         OnBoardingResult onBoardResultObj = new OnBoardingResult();
1145         onBoardResultObj.setCsarId("csrId");
1146         onBoardResultObj.setOperStatus(1);
1147         boolean res = FileUtil.writeJsonDatatoFile(filePath, onBoardResultObj);
1148         assertEquals(res, true);
1149         String filePath1 = "src//test//resources";
1150         res = FileUtil.writeJsonDatatoFile(filePath1, onBoardResultObj);
1151         assertEquals(res, false);
1152
1153     }
1154
1155     @Test
1156
1157     public void testCreateDirectory() {
1158         String dirPath = "src//test//resources//TestDirectory";
1159         boolean res = FileUtil.createDirectory(dirPath);
1160         assertEquals(res, true);
1161     }
1162
1163     @Test
1164
1165     public void testDeleteDirectory() {
1166         String dirPath = "src//test//resources//TestDirectory";
1167         boolean res = FileUtil.deleteFile(dirPath);
1168         assertEquals(res, true);
1169         String dirPath1 = "src//test//resources11";
1170         res = FileUtil.deleteFile(dirPath1);
1171         assertEquals(res, true);
1172
1173     }
1174
1175     @Test
1176
1177     public void testGenerateId() {
1178         String id = MarketplaceDbUtil.generateId();
1179         assertNotNull(id);
1180     }
1181
1182     @Test
1183     public void testisNotEmpty() {
1184         boolean res = MarketplaceDbUtil.isNotEmpty(null);
1185         assertEquals(res, false);
1186         res = MarketplaceDbUtil.isNotEmpty("test");
1187         assertEquals(res, true);
1188     }
1189
1190     @Test
1191     public void testobjectToString() {
1192         Object obj = "testexa";
1193         String res = MarketplaceDbUtil.objectToString(obj);
1194         assertNotNull(res);
1195         res = MarketplaceDbUtil.objectToString(null);
1196         assertNull(res);
1197     }
1198
1199     @Test
1200     public void testisEmptyString() {
1201         boolean res = ToolUtil.isEmptyString(null);
1202         assertEquals(res, true);
1203         res = ToolUtil.isEmptyString("huawei");
1204         assertEquals(res, false);
1205     }
1206
1207     @Test
1208     public void testisTrimedEmptyString() {
1209         boolean res = ToolUtil.isTrimedEmptyString(null);
1210         assertEquals(res, true);
1211         res = ToolUtil.isTrimedEmptyString("    ");
1212         assertEquals(res, true);
1213     }
1214
1215     @Test
1216     public void testisEmptyCollection() {
1217
1218         boolean res = ToolUtil.isEmptyCollection(new ArrayList());
1219         assertEquals(res, true);
1220     }
1221
1222     @Test
1223     public void testisYamlFile() {
1224         File fileObj = new File("test.txt");
1225         boolean res = ToolUtil.isYamlFile(fileObj);
1226         assertEquals(res, false);
1227     }
1228
1229     @Test
1230     public void testgenerateID() {
1231         String id = ToolUtil.generateId();
1232         assertNotNull(id);
1233     }
1234
1235     @Test
1236     public void testgetFormatFileSize() {
1237         String res = ToolUtil.getFormatFileSize(10000000);
1238         assertNotNull(res);
1239         res = ToolUtil.getFormatFileSize(10000);
1240         assertNotNull(res);
1241         res = ToolUtil.getFormatFileSize(100);
1242         assertNotNull(res);
1243     }
1244
1245     @Test
1246     public void testObjectToString() {
1247         Object obj = "testexa";
1248         String res = ToolUtil.objectToString(obj);
1249         assertNotNull(res);
1250         res = ToolUtil.objectToString(null);
1251         assertNotNull(res);
1252     }
1253
1254     @Test
1255     public void testprocessFileName() {
1256         String res = ToolUtil.processFileName("abc.txt");
1257         assertNotNull(res);
1258         res = ToolUtil.processFileName("abc.zip");
1259         assertNotNull(res);
1260     }
1261
1262     @Test
1263     public void testremoveCsarSuffix() {
1264         String res = ToolUtil.removeCsarSuffix("abc.csar");
1265         assertEquals(res, "abc");
1266     }
1267
1268     @Test
1269     public void testformatCsar() {
1270         String res = ToolUtil.formatCsar("abc");
1271         assertEquals(res, "abc.csar");
1272     }
1273
1274     @Test
1275     public void testformatFileSize() {
1276         String res = ToolUtil.formatFileSize(10000.0, 10);
1277         String expected = new DecimalFormat("#0.00").format(1000) + "M";// may
1278                                                                         // be
1279                                                                         // "1000.00"
1280                                                                         // or
1281                                                                         // "1000,00"
1282                                                                         // depending
1283                                                                         // on
1284                                                                         // Locale
1285         assertEquals(res, expected);
1286     }
1287
1288     @Test
1289     public void testgetFileSize() {
1290         File fileObj = new File("example.txt");
1291         String res = ToolUtil.getFileSize(fileObj, 10);
1292         assertNotNull(res);
1293     }
1294
1295     @Test
1296     public void testgetCatalogueCsarPath() {
1297         String res = ToolUtil.getCatalogueCsarPath();
1298         assertEquals(res, File.separator + "csar");
1299     }
1300
1301     @Test
1302     public void testgetCatalogueImagePath() {
1303         String res = ToolUtil.getCatalogueImagePath();
1304         assertEquals(res, File.separator + "image");
1305     }
1306
1307     @Test
1308     public void testdeleteFile() {
1309         boolean res = ToolUtil.deleteFile("src//test//resources", "test1.txt");
1310         assertEquals(res, true);
1311     }
1312
1313     @Test
1314     public void teststoreChunkFileInLocal() {
1315         try {
1316             inputStream = new FileInputStream("src//test//resources//Test.txt");
1317             String res = ToolUtil.storeChunkFileInLocal("src//test//resources", "TestOut.txt", inputStream);
1318             File file = new File(res);
1319             String fileName = file.getName();
1320             assertEquals(fileName, "TestOut.txt");
1321
1322         } catch(Exception ex) {
1323             ex.printStackTrace();
1324         }
1325     }
1326
1327     @Test
1328     public void testToolUtildeleteFile() {
1329         boolean res = ToolUtil.deleteFile("src/test/resources", "TestOut.txt");
1330         assertEquals(res, true);
1331     }
1332
1333
1334     @Test
1335     public void testUnzip() {
1336
1337         List<String> listObj = new ArrayList<String>();
1338         try {
1339             listObj = FileUtil.unzip("src/test/resources/temp.zip", "src/test/resources/testfolder");
1340         } catch(Exception ex) {
1341             ex.printStackTrace();
1342         }
1343         assertNotNull(listObj);
1344     }
1345
1346     @Test
1347     public void testreadJsonDatafFromFile() {
1348
1349         Object obj =
1350                 FileUtil.readJsonDatafFromFile("src/main/resources/generalconfig/OnBoardingSteps.json", Object.class);
1351         assertNotNull(obj);
1352     }
1353
1354     @Test
1355     public void testvalidateFile() {
1356         File fileData= null;
1357         boolean res = FileUtil.validateFile(fileData);
1358         assertEquals(res, false);
1359     }
1360
1361     @Test
1362     public void testGetPkgSize() {
1363         long pkgSize = PackageWrapperUtil.getPacakgeSize("src/test/resources/Test.txt");
1364         assertNotNull(pkgSize);
1365     }
1366
1367     @Test
1368     public void testPkgFormat() {
1369         assertNotNull(PackageWrapperUtil.getPackageFormat("xml"));
1370         assertNotNull(PackageWrapperUtil.getPackageFormat("yml"));
1371         assertNull(PackageWrapperUtil.getPackageFormat("pdf"));
1372
1373         MsbDetailsHolder.getMsbDetails();
1374         try {
1375             IMarketplaceDao dao = new MarketplaceDaoImpl();
1376
1377             packageDataList = new ArrayList<PackageData>();
1378             packageData = new PackageData();
1379             packageData.setCsarId("21");
1380             packageData.setDownloadUri("src\\test\\resources\\");
1381             packageData.setName("clearwater_ns.csar");
1382             packageData.setSize("59,854  bytes");
1383             packageData.setVersion("v1.0");
1384             packageData.setProvider("Huawei");
1385             packageDataList.add(packageData);
1386
1387             dao.savePackageData(packageData);
1388             dao.getAllPackageData();
1389             dao.getPackageData("21");
1390             dao.updatePackageData(packageData);
1391             dao.deletePackageData("21");
1392
1393         } catch(Exception e) {
1394         }
1395
1396     }
1397
1398     @Test
1399     public void testVnfPackageSetter() {
1400
1401         vnfPackageObj.setVnfPackageId("vnfpackageId");
1402         vnfPackageObj.setVnfPackageUrl("vnfPackageUrl");
1403         vnfPackageObj.setVnfd("vnfd");
1404         vnfPackageObj.setVersion("1");
1405         vnfPackageObj.setUsageState(EnumUsageState.NOTINUSE);
1406         vnfPackageObj.setProvider("huawei");
1407         vnfPackageObj.setOperationalState(EnumOperationalState.ENABLED);
1408         vnfPackageObj.setName("vnf");
1409         vnfPackageObj.setDeletionPending("pending");
1410
1411         String res = vnfPackageObj.getVnfPackageId();
1412         assertEquals(res, "vnfpackageId");
1413         res = vnfPackageObj.getVnfPackageUrl();
1414         assertEquals(res, "vnfPackageUrl");
1415         res = vnfPackageObj.getVnfd();
1416         assertEquals(res, "vnfd");
1417         res = vnfPackageObj.getVersion();
1418         assertEquals(res, "1");
1419         EnumUsageState state = vnfPackageObj.getUsageState();
1420         assertEquals(state, EnumUsageState.NOTINUSE);
1421         res = vnfPackageObj.getProvider();
1422         assertEquals(res, "huawei");
1423         EnumOperationalState operState = vnfPackageObj.getOperationalState();
1424         assertEquals(operState, EnumOperationalState.ENABLED);
1425         res = vnfPackageObj.getName();
1426         assertEquals(res, "vnf");
1427         res = vnfPackageObj.getDeletionPending();
1428         assertEquals(res, "pending");
1429     }
1430
1431     @Test
1432     public void testCsarPackageSetter() {
1433         csarPackageObj.setCreateTime("04052017");
1434         csarPackageObj.setDeletionPending("pending");
1435         csarPackageObj.setFormat("format");
1436         csarPackageObj.setId("12");
1437         csarPackageObj.setName("csartest");
1438         csarPackageObj.setSize("10");
1439         csarPackageObj.setStatus("done");
1440         csarPackageObj.setType("type");
1441         csarPackageObj.setUrl("//network");
1442
1443         String res = csarPackageObj.getCreateTime();
1444         assertEquals(res, "04052017");
1445         res = csarPackageObj.getDeletionPending();
1446         assertEquals(res, "pending");
1447         res = csarPackageObj.getFormat();
1448         assertEquals(res, "format");
1449         res = csarPackageObj.getId();
1450         assertEquals(res, "12");
1451         res = csarPackageObj.getName();
1452         assertEquals(res, "csartest");
1453         res = csarPackageObj.getSize();
1454         assertEquals(res, "10");
1455         res = csarPackageObj.getStatus();
1456         assertEquals(res, "done");
1457         res = csarPackageObj.getType();
1458         assertEquals(res, "type");
1459         res = csarPackageObj.getUrl();
1460         assertEquals(res, "//network");
1461
1462     }
1463
1464     @Test
1465     public void testPackageBasicInfoSetter() {
1466         pkgBasicInfoObj.setFormat("pdf");
1467         pkgBasicInfoObj.setProvider("huawei");
1468         pkgBasicInfoObj.setType(EnumType.GSAR);
1469         pkgBasicInfoObj.setVersion("1");
1470         String res = pkgBasicInfoObj.getFormat();
1471         assertEquals(res, "pdf");
1472         res = pkgBasicInfoObj.getProvider();
1473         assertEquals(res, "huawei");
1474         EnumType type = pkgBasicInfoObj.getType();
1475         assertEquals(type, EnumType.GSAR);
1476         res = pkgBasicInfoObj.getVersion();
1477         assertEquals(res, "1");
1478     }
1479
1480     @Test
1481     public void testPackageMetaSetter() {
1482         pkgMetaObj.setCreateTime("05042017");
1483         pkgMetaObj.setCsarId("csarid");
1484         pkgMetaObj.setDeletionPending(true);
1485         pkgMetaObj.setDetails("details");
1486         pkgMetaObj.setDownloadCount(10);
1487         pkgMetaObj.setDownloadUri("//network");
1488         pkgMetaObj.setFormat("pdf");
1489         pkgMetaObj.setModifyTime("05042017");
1490         pkgMetaObj.setName("huawei");
1491         pkgMetaObj.setProvider("huawei");
1492         pkgMetaObj.setRemarks("tested");
1493         pkgMetaObj.setReport("done");
1494         pkgMetaObj.setShortDesc("done");
1495         pkgMetaObj.setSize("1000");
1496         pkgMetaObj.setType("type");
1497         pkgMetaObj.setVersion("1");
1498
1499         String res = pkgMetaObj.getCreateTime();
1500         assertEquals(res, "05042017");
1501         res = pkgMetaObj.getCsarId();
1502         assertEquals(res, "csarid");
1503         res = pkgMetaObj.getDetails();
1504         assertEquals(res, "details");
1505         res = pkgMetaObj.getDownloadCount() + "";
1506         assertEquals(res, "10");
1507         res = pkgMetaObj.getDownloadUri();
1508         assertEquals(res, "//network");
1509         res = pkgMetaObj.getFormat();
1510         assertEquals(res, "pdf");
1511         res = pkgMetaObj.getModifyTime();
1512         assertEquals(res, "05042017");
1513         res = pkgMetaObj.getName();
1514         assertEquals(res, "huawei");
1515         res = pkgMetaObj.getProvider();
1516         assertEquals(res, "huawei");
1517         res = pkgMetaObj.getRemarks();
1518         assertEquals(res, "tested");
1519         res = pkgMetaObj.getReport();
1520         assertEquals(res, "done");
1521         res = pkgMetaObj.getShortDesc();
1522         assertEquals(res, "done");
1523         res = pkgMetaObj.getSize();
1524         assertEquals(res, "1000");
1525         res = pkgMetaObj.getType();
1526         assertEquals(res, "type");
1527         res = pkgMetaObj.getVersion();
1528         assertEquals(res, "1");
1529     }
1530
1531     @Test
1532     public void testPackageResponseSetter() {
1533         pkgResponseObj.setReportPath("localpath");
1534         String res = pkgResponseObj.getReportPath();
1535         assertEquals(res, "localpath");
1536
1537     }
1538
1539     @Test
1540     public void testCsarFileUriResSetter() {
1541         csarFileUriResObj.setDownloadUri("downloaduri");
1542         csarFileUriResObj.setLocalPath("localpath");
1543         String res = csarFileUriResObj.getDownloadUri();
1544         assertEquals(res, "downloaduri");
1545         res = csarFileUriResObj.getLocalPath();
1546         assertEquals(res, "localpath");
1547
1548     }
1549 }