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