vnfmarket-be/vnf-sdk-marketplace/src/test/java/org/onap/vnfsdk/marketplace/resource/PackageResourceTest.java

   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             assertNotNull(response);
 684         } catch(Exception e) {
 685             e.printStackTrace();
 686         }
 687
 688
 689     }
 690
 691     // @Ignore
 692     @Test
 693     public void testUploadPackage() throws Exception {
 694         InputStream ins = null;
 695         Response result = null;
 696         /*
 697          * Response result1 = null; Response result2 = null; PackageData
 698          * packageData = new PackageData(); packageData = getPackageData();
 699          */
 700
 701         new MockUp<MarketplaceDaoImpl>() {
 702
 703             @Mock
 704             public List<PackageData> getPackageData(String csarId) {
 705                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 706                 PackageData packageData = new PackageData();
 707                 packageData = new PackageData();
 708                 packageData.setCsarId(csarId);
 709                 packageData.setDownloadUri("src\\test\\resources\\");
 710                 packageData.setName("clearwater_ns.csar");
 711                 packageData.setSize("59,854  bytes");
 712                 packageData.setVersion("v1.0");
 713                 packageData.setProvider("Airtel");
 714                 packageDataList.add(packageData);
 715                 return packageDataList;
 716             }
 717
 718             @Mock
 719             public List<PackageData> getPackageDataSubset(Map<String, String> paramsMap) {
 720                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 721
 722                 return packageDataList;
 723             }
 724         };
 725
 726         new MockUp<HttpFileManagerImpl>() {
 727
 728             @Mock
 729             public boolean delete(String srcPath) {
 730                 return true;
 731             }
 732         };
 733
 734         new MockUp<MarketplaceDaoImpl>() {
 735
 736             @Mock
 737             public void deletePackageData(String csarId) {
 738                 return;
 739             }
 740         };
 741
 742         new MockUp<ToolUtil>() {
 743
 744             @Mock
 745             public String getTempDir(String dirName, String fileName) {
 746                 String filena =
 747                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 748                 return filena;
 749             }
 750         };
 751
 752         new MockUp<HttpFileManagerImpl>() {
 753
 754             @Mock
 755             public boolean upload(String srcPath, String dstPath) {
 756                 return false;
 757             }
 758         };
 759
 760         new MockUp<PackageHandler>() {
 761
 762             @Mock
 763             public PackageData create(PackageData packageData) {
 764                 PackageData packageDataObj = new PackageData();
 765                 packageDataObj.setCreateTime("25-3-2017 15:26:00");
 766                 packageDataObj.setDeletionPending("deletion");
 767                 packageDataObj.setDownloadUri("downloaduri");
 768                 packageDataObj.setFormat("format");
 769                 packageDataObj.setModifyTime("modifytime");
 770                 packageDataObj.setName("name");
 771                 packageDataObj.setCsarId("csarid");
 772                 packageDataObj.setProvider("huawei");
 773                 String fileSize = "10 mb";
 774                 packageDataObj.setSize(fileSize);
 775                 packageDataObj.setType("type");
 776                 packageDataObj.setVersion("v2.0");
 777                 packageDataObj.setDetails("details");
 778                 packageDataObj.setShortDesc("description");
 779                 packageDataObj.setRemarks("remarks");
 780                 return packageDataObj;
 781             }
 782         };
 783
 784
 785         new MockUp<OpenRemoteCli>() {
 786
 787             @Mock
 788             public Result run(String host, int port, String reqId, List <String> args) {
 789                 Result result = Result.newBuilder().
 790                         setExitCode(0).
 791                         setOutput("{\"error\":\"SUCCESS\"}").
 792                         build();
 793
 794                 return result;
 795             }
 796         };
 797
 798         FormDataContentDisposition fileDetail =
 799                 FormDataContentDisposition.name("fileName").fileName("clearwater_ns.csar").build();
 800
 801         String filenama =
 802                 "src" + File.separator + "test" + File.separator + "resources" + File.separator + "clearwater_ns.csar";
 803         File packageFile = new File(filenama);
 804
 805         try {
 806             ins = new FileInputStream(packageFile);
 807         } catch(FileNotFoundException e2) {
 808             e2.printStackTrace();
 809         }
 810         if(ins != null) {
 811             try {
 812                 result = PackageWrapper.getInstance().uploadPackage(ins, fileDetail, null, null);
 813                 // PackageWrapper.getInstance().updateValidateStatus(ins);
 814             } catch(Exception e3) {
 815                 e3.printStackTrace();
 816             }
 817         }
 818
 819         assertNotNull(result);
 820         assertEquals(200, result.getStatus());
 821
 822         try {
 823             result = PackageWrapper.getInstance().uploadPackage(null, null, null, null);
 824         } catch(Exception e4) {
 825             e4.printStackTrace();
 826         }
 827
 828         assertEquals(417, result.getStatus());
 829
 830         try {
 831             response = packageResource.uploadPackage(null, null, null, null);
 832         } catch(Exception e) {
 833             e.printStackTrace();
 834         }
 835     }
 836
 837     @Test
 838     public void testUploadPackageFailedOnVtp() throws Exception {
 839         InputStream ins = null;
 840         Response result = null;
 841         /*
 842          * Response result1 = null; Response result2 = null; PackageData
 843          * packageData = new PackageData(); packageData = getPackageData();
 844          */
 845
 846         new MockUp<MarketplaceDaoImpl>() {
 847
 848             @Mock
 849             public List<PackageData> getPackageData(String csarId) {
 850                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 851                 PackageData packageData = new PackageData();
 852                 packageData = new PackageData();
 853                 packageData.setCsarId(csarId);
 854                 packageData.setDownloadUri("src\\test\\resources\\");
 855                 packageData.setName("clearwater_ns.csar");
 856                 packageData.setSize("59,854  bytes");
 857                 packageData.setVersion("v1.0");
 858                 packageData.setProvider("Airtel");
 859                 packageDataList.add(packageData);
 860                 return packageDataList;
 861             }
 862
 863             @Mock
 864             public List<PackageData> getPackageDataSubset(Map<String, String> paramsMap) {
 865                 List<PackageData> packageDataList = new ArrayList<PackageData>();
 866
 867                 return packageDataList;
 868             }
 869         };
 870
 871         new MockUp<HttpFileManagerImpl>() {
 872
 873             @Mock
 874             public boolean delete(String srcPath) {
 875                 return true;
 876             }
 877         };
 878
 879         new MockUp<MarketplaceDaoImpl>() {
 880
 881             @Mock
 882             public void deletePackageData(String csarId) {
 883                 return;
 884             }
 885         };
 886
 887         new MockUp<ToolUtil>() {
 888
 889             @Mock
 890             public String getTempDir(String dirName, String fileName) {
 891                 String filena =
 892                         "src" + File.separator + "test" + File.separator + "resources" + File.separator + "testfolder";
 893                 return filena;
 894             }
 895         };
 896
 897         new MockUp<HttpFileManagerImpl>() {
 898
 899             @Mock
 900             public boolean upload(String srcPath, String dstPath) {
 901                 return false;
 902             }
 903         };
 904
 905         new MockUp<PackageWrapperUtil>() {
 906
 907             @Mock
 908             public PackageData getPackageData(PackageMeta meta) {
 909                 PackageData packageData = new PackageData();
 910                 packageData.setCreateTime("25-3-2017 15:26:00");
 911                 packageData.setDeletionPending("deletion");
 912                 packageData.setDownloadUri("downloaduri");
 913                 packageData.setFormat("format");
 914                 packageData.setModifyTime("time");
 915                 packageData.setName("name");
 916                 packageData.setCsarId("csarid");
 917                 packageData.setProvider("huawei");
 918                 String fileSize = "10 mb";
 919                 packageData.setSize(fileSize);
 920                 packageData.setType("type");
 921                 packageData.setVersion("v2.0");
 922                 packageData.setDetails("details");
 923                 packageData.setShortDesc("description");
 924                 packageData.setRemarks("remarks");
 925                 return packageData;
 926             }
 927         };
 928
 929         new MockUp<PackageHandler>() {
 930
 931             @Mock
 932             public PackageData create(PackageData packageData) {
 933                 PackageData packageDataObj = new PackageData();
 934                 packageDataObj.setCreateTime("25-3-2017 15:26:00");
 935                 packageDataObj.setDeletionPending("deletion");
 936                 packageDataObj.setDownloadUri("downloaduri");
 937                 packageDataObj.setFormat("format");
 938                 packageDataObj.setModifyTime("modifytime");
 939                 packageDataObj.setName("name");
 940                 packageDataObj.setCsarId("csarid");
 941                 packageDataObj.setProvider("huawei");
 942                 String fileSize = "10 mb";
 943                 packageDataObj.setSize(fileSize);
 944                 packageDataObj.setType("type");
 945                 packageDataObj.setVersion("v2.0");
 946                 packageDataObj.setDetails("details");
 947                 packageDataObj.setShortDesc("description");
 948                 packageDataObj.setRemarks("remarks");
 949                 return packageDataObj;
 950             }
 951         };
 952
 953
 954         new MockUp<OpenRemoteCli>() {
 955
 956             @Mock
 957             public Result run(String host, int port, String reqId, List <String> args) throws Exception {
 958                 throw new Exception();
 959             }
 960         };
 961
 962         FormDataContentDisposition fileDetail =
 963                 FormDataContentDisposition.name("fileName").fileName("clearwater_ns.csar").build();
 964
 965         String filenama =
 966                 "src" + File.separator + "test" + File.separator + "resources" + File.separator + "clearwater_ns.csar";
 967         File packageFile = new File(filenama);
 968
 969         try {
 970             ins = new FileInputStream(packageFile);
 971         } catch(FileNotFoundException e2) {
 972             e2.printStackTrace();
 973         }
 974         if(ins != null) {
 975             try {
 976                 result = PackageWrapper.getInstance().uploadPackage(ins, fileDetail, null, null);
 977                 // PackageWrapper.getInstance().updateValidateStatus(ins);
 978             } catch(Exception e3) {
 979                 e3.printStackTrace();
 980             }
 981         }
 982
 983         assertEquals(200, result.getStatus());
 984     }
 985
 986     @Test
 987     public void testGetOnBoardingStepsSuccess() {
 988         new MockUp<org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil>() {
 989
 990             @Mock
 991             String getAppDeployPath() {
 992                 String path = "src" + File.separator + "main" + File.separator + "resources";
 993                 return path;
 994             }
 995         };
 996
 997         try {
 998             response = PackageWrapper.getInstance().getOnBoardingSteps();
 999         } catch(Exception e) {
1000             e.printStackTrace();
1001         }
1002
1003         assertNotNull(response);
1004
1005         try {
1006             response = packageResource.getOnBoardingSteps();
1007         } catch(Exception e) {
1008             e.printStackTrace();
1009         }
1010     }
1011
1012     @Test
1013     public void testGetOOprStatusSuccess() {
1014         try {
1015             response = packageResource.getOperStatus(null, null);
1016             assertNotNull(response);
1017         } catch(Exception e) {
1018             e.printStackTrace();
1019         }
1020     }
1021
1022     @Test
1023     public void testUpdateStatusSuccess(@Mocked HttpServletRequest request) {
1024         new MockUp<ServletRequest>() {
1025
1026             @Mock
1027             public ServletInputStream getInputStream() throws IOException {
1028                   ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
1029                           "{\"csar\"=\"VoLTE.csar\"}".getBytes());
1030
1031                   return new ServletInputStream(){
1032                     public int read() throws IOException {
1033                       return byteArrayInputStream.read();
1034                     }
1035
1036                     @Override
1037                     public boolean isFinished() {
1038                         return true;
1039                     }
1040
1041                     @Override
1042                     public boolean isReady() {
1043                         return true;
1044                     }
1045
1046                     @Override
1047                     public void setReadListener(ReadListener arg0) {
1048                     }
1049                   };
1050                 }
1051
1052         };
1053         try {
1054             response = packageResource.updateValidateStatus(request, null);
1055             assertNotNull(response);
1056         } catch(Exception e) {
1057             e.printStackTrace();
1058         }
1059     }
1060
1061     @Test
1062     public void testGetOnBoardingStepsFailure() {
1063         new MockUp<org.onap.vnfsdk.marketplace.filemanage.http.ToolUtil>() {
1064
1065             @Mock
1066             String getAppDeployPath() {
1067                 String path = "src" + File.separator + "main" + File.separator + "resources" + File.separator
1068                         + "generalconfig";
1069                 return path;
1070             }
1071         };
1072
1073         try {
1074             response = PackageWrapper.getInstance().getOnBoardingSteps();
1075         } catch(Exception e) {
1076             e.printStackTrace();
1077         }
1078         assertEquals(500, response.getStatus());
1079     }
1080
1081     @Test
1082     public void testRestGetClient() {
1083         new MockUp<RestfulClient>() {
1084             @Mock
1085             RestResponse get(String ip, int port, String url) {
1086                 RestResponse restResponse = new RestResponse();
1087                 restResponse.setStatusCode(200);
1088                 restResponse.setResult("success");
1089                 return restResponse;
1090             }
1091         };
1092         String dirPath = "etc//conf//restclient.json";
1093        FileUtil.createDirectory(dirPath);
1094         MsbServer msbServer = new MsbServer();
1095         msbServer.setHost("localhost");
1096         msbServer.setPort("8080");
1097         Map<String, MsbServer> map = new HashMap<>();
1098         map.put("defaultServer", msbServer);
1099         FileUtil.writeJsonDatatoFile(dirPath, map);
1100         assertNotNull(FunctionTestExceutor.getTestResultsByFuncTestKey("GET"));
1101         FileUtil.deleteDirectory("etc");
1102
1103     }
1104
1105     @Test
1106     public void testRestPostClient() {
1107
1108         OnBoradingRequest onBoradFuncTestReq = new OnBoradingRequest();
1109         onBoradFuncTestReq.setPackagePath("src/test/resources/clearwater_ns.csar");
1110         onBoradFuncTestReq.setPackageName("clearwater_ns.csar");
1111         String result = FunctionTestExceutor.execFunctionTest(onBoradFuncTestReq);
1112         assertNull(result);
1113         // assertEquals(200,result);
1114
1115     }
1116
1117     @Test
1118     public void testRestDeleteClient() {
1119         RestResponse rsp = RestfulClient.delete("127.0.0.1", 8987, "TestURL");
1120         assertNotNull(rsp);
1121         if(rsp.getStatusCode() != null)
1122             assertEquals(200, rsp.getStatusCode().intValue());
1123
1124     }
1125
1126     @Test
1127     public void testExec() {
1128
1129         new MockUp<FunctionTestHook>() {
1130
1131             @Mock
1132             String getResultStorePath() {
1133                 return "src/test/resources";
1134
1135             }
1136         };
1137         FunctionTestHook testHookObj = new FunctionTestHook();
1138         OnBoradingRequest onBoradFuncTestReq = new OnBoradingRequest();
1139         onBoradFuncTestReq.setPackagePath("src/test/resources/clearwater_ns.csar");
1140         int res = testHookObj.exec(onBoradFuncTestReq);
1141
1142         assertEquals(res, -1);
1143     }
1144
1145     @Test
1146
1147     public void testwriteJsonDatatoFile() {
1148
1149         String filePath = "src//test//resources//functionTest.json";
1150         OnBoardingResult onBoardResultObj = new OnBoardingResult();
1151         onBoardResultObj.setCsarId("csrId");
1152         onBoardResultObj.setOperStatus(1);
1153         boolean res = FileUtil.writeJsonDatatoFile(filePath, onBoardResultObj);
1154         assertTrue(res);
1155         String filePath1 = "src//test//resources";
1156         res = FileUtil.writeJsonDatatoFile(filePath1, onBoardResultObj);
1157         assertFalse(res);
1158
1159     }
1160
1161     @Test
1162
1163     public void testCreateDirectory() {
1164         String dirPath = "src//test//resources//TestDirectory";
1165         boolean res = FileUtil.createDirectory(dirPath);
1166         assertTrue(res);
1167     }
1168
1169     @Test
1170
1171     public void testDeleteDirectory() {
1172         String dirPath = "src//test//resources//TestDirectory";
1173         boolean res = FileUtil.deleteFile(dirPath);
1174         assertTrue(res);
1175         String dirPath1 = "src//test//resources11";
1176         res = FileUtil.deleteFile(dirPath1);
1177         assertTrue(res);
1178
1179     }
1180
1181     @Test
1182
1183     public void testGenerateId() {
1184         String id = MarketplaceDbUtil.generateId();
1185         assertNotNull(id);
1186     }
1187
1188     @Test
1189     public void testisNotEmpty() {
1190         boolean res = MarketplaceDbUtil.isNotEmpty(null);
1191         assertFalse(res);
1192         res = MarketplaceDbUtil.isNotEmpty("test");
1193         assertTrue(res);
1194     }
1195
1196     @Test
1197     public void testobjectToString() {
1198         Object obj = "testexa";
1199         String res = MarketplaceDbUtil.objectToString(obj);
1200         assertNotNull(res);
1201         res = MarketplaceDbUtil.objectToString(null);
1202         assertNull(res);
1203     }
1204
1205     @Test
1206     public void testisEmptyString() {
1207         boolean res = ToolUtil.isEmptyString(null);
1208         assertTrue(res);
1209         res = ToolUtil.isEmptyString("huawei");
1210         assertFalse(res);
1211     }
1212
1213     @Test
1214     public void testisTrimedEmptyString() {
1215         boolean res = ToolUtil.isTrimedEmptyString(null);
1216         assertTrue(res);
1217         res = ToolUtil.isTrimedEmptyString(" huawei ");
1218         assertFalse(res);
1219
1220     }
1221     @Test
1222     public void testisTrimedEmptyArray() {
1223         boolean res = ToolUtil.isTrimedEmptyArray(null);
1224         assertTrue(res);
1225         String[] String1={"hua","wei"};
1226         res = ToolUtil.isTrimedEmptyArray(String1);
1227         assertFalse(res);
1228     }
1229
1230     @Test
1231     public void testisEmptyCollection() {
1232         ArrayList arr1 = new ArrayList();
1233         boolean res = ToolUtil.isEmptyCollection(arr1);
1234         assertTrue(res);
1235         arr1.add("huawei");
1236         res = ToolUtil.isEmptyCollection(arr1);
1237         assertFalse(res);
1238     }
1239
1240     @Test
1241     public void testisYamlFile() {
1242         File fileObj = new File("test.yaml");
1243         boolean res = ToolUtil.isYamlFile(fileObj);
1244         assertTrue(res);
1245     }
1246
1247     @Test
1248     public void testgenerateID() {
1249         String id = ToolUtil.generateId();
1250         assertNotNull(id);
1251     }
1252
1253     @Test
1254     public void testgetFormatFileSize() {
1255         long fileSize = 1000*1000*1000*100;
1256         String res = ToolUtil.getFormatFileSize(fileSize);
1257         assertNotNull(res);
1258         res = ToolUtil.getFormatFileSize(1000000000);
1259         assertNotNull(res);
1260         res = ToolUtil.getFormatFileSize(200000);
1261         assertNotNull(res);
1262         res = ToolUtil.getFormatFileSize(100000);
1263         assertNotNull(res);
1264         res = ToolUtil.getFormatFileSize(100);
1265         assertNotNull(res);
1266     }
1267
1268     @Test
1269     public void testObjectToString() {
1270         Object obj = "testexa";
1271         String res = ToolUtil.objectToString(obj);
1272         assertNotNull(res);
1273         res = ToolUtil.objectToString(null);
1274         assertNotNull(res);
1275     }
1276
1277     @Test
1278     public void testprocessFileName() {
1279         String res = ToolUtil.processFileName("abc.txt");
1280         assertNotNull(res);
1281         res = ToolUtil.processFileName("abc.zip");
1282         assertNotNull(res);
1283         res = ToolUtil.processFileName("abc");
1284         assertNotNull(res);
1285     }
1286
1287     @Test
1288     public void testremoveCsarSuffix() {
1289         String res = ToolUtil.removeCsarSuffix("abc.csar");
1290         assertEquals("abc", res);
1291     }
1292
1293     @Test
1294     public void testformatCsar() {
1295         String res = ToolUtil.formatCsar("abc");
1296         assertEquals("abc.csar", res);
1297     }
1298
1299     @Test
1300     public void testformatFileSize() {
1301         String res = ToolUtil.formatFileSize(10000.0, 10);
1302         String expected = new DecimalFormat("#0.00").format(1000) + "M";// may
1303                                                                         // be
1304                                                                         // "1000.00"
1305                                                                         // or
1306                                                                         // "1000,00"
1307                                                                         // depending
1308                                                                         // on
1309                                                                         // Locale
1310         assertEquals(expected, res);
1311     }
1312
1313     @Test
1314     public void testgetFileSize() {
1315         File fileObj = new File("example.txt");
1316         String res = ToolUtil.getFileSize(fileObj, 10);
1317         assertNotNull(res);
1318     }
1319
1320     @Test
1321     public void testgetCatalogueCsarPath() {
1322         String res = ToolUtil.getCatalogueCsarPath();
1323         assertEquals(File.separator + "csar", res);
1324     }
1325
1326     @Test
1327     public void testgetCatalogueImagePath() {
1328         String res = ToolUtil.getCatalogueImagePath();
1329         assertEquals(File.separator + "image", res);
1330     }
1331
1332     @Test
1333     public void testdeleteFile() {
1334         boolean res = ToolUtil.deleteFile("src//test//resources", "test1.txt");
1335         assertTrue(res);
1336     }
1337
1338     @Test
1339     public void teststoreChunkFileInLocal() {
1340         try {
1341             inputStream = new FileInputStream("src//test//resources//Test.txt");
1342             String res = ToolUtil.storeChunkFileInLocal("src//test//resources", "TestOut.txt", inputStream);
1343             File file = new File(res);
1344             String fileName = file.getName();
1345             assertEquals("TestOut.txt", fileName);
1346
1347         } catch(Exception ex) {
1348             ex.printStackTrace();
1349         }
1350     }
1351
1352     @Test
1353     public void testToolUtildeleteFile() {
1354
1355         boolean res = ToolUtil.deleteFile("src/test/resources", "TestOut.txt");
1356         assertTrue(res);
1357     }
1358
1359
1360     @Test
1361     public void testUnzip() {
1362
1363         List<String> listObj = new ArrayList<String>();
1364         try {
1365             listObj = FileUtil.unzip("src/test/resources/temp.zip", "src/test/resources/testfolder");
1366         } catch(Exception ex) {
1367             ex.printStackTrace();
1368         }
1369         assertNotNull(listObj);
1370     }
1371
1372     @Test
1373     public void testreadJsonDatafFromFile() {
1374
1375         Object obj =
1376                 FileUtil.readJsonDatafFromFile("src/main/resources/generalconfig/OnBoardingSteps.json", Object.class);
1377         assertNotNull(obj);
1378     }
1379
1380     @Test
1381     public void testvalidateFile() {
1382         File fileData= null;
1383         boolean res = FileUtil.validateFile(fileData);
1384         assertFalse(res);
1385     }
1386
1387     @Test
1388     public void testGetPkgSize() {
1389         long pkgSize = PackageWrapperUtil.getPacakgeSize("src/test/resources/Test.txt");
1390         assertTrue(pkgSize > 1);
1391     }
1392
1393     @Test
1394     public void testPkgFormat() {
1395         assertNotNull(PackageWrapperUtil.getPackageFormat("xml"));
1396         assertNotNull(PackageWrapperUtil.getPackageFormat("yml"));
1397         assertNull(PackageWrapperUtil.getPackageFormat("pdf"));
1398
1399         MsbDetailsHolder.getMsbDetails();
1400         try {
1401             IMarketplaceDao dao = new MarketplaceDaoImpl();
1402
1403             packageDataList = new ArrayList<PackageData>();
1404             packageData = new PackageData();
1405             packageData.setCsarId("21");
1406             packageData.setDownloadUri("src\\test\\resources\\");
1407             packageData.setName("clearwater_ns.csar");
1408             packageData.setSize("59,854  bytes");
1409             packageData.setVersion("v1.0");
1410             packageData.setProvider("Huawei");
1411             packageDataList.add(packageData);
1412
1413             dao.savePackageData(packageData);
1414             dao.getAllPackageData();
1415             dao.getPackageData("21");
1416             dao.updatePackageData(packageData);
1417             dao.deletePackageData("21");
1418
1419         } catch(Exception e) {
1420         }
1421
1422     }
1423
1424     @Test
1425     public void testVnfPackageSetter() {
1426
1427         vnfPackageObj.setVnfPackageId("vnfpackageId");
1428         vnfPackageObj.setVnfPackageUrl("vnfPackageUrl");
1429         vnfPackageObj.setVnfd("vnfd");
1430         vnfPackageObj.setVersion("1");
1431         vnfPackageObj.setUsageState(EnumUsageState.NOTINUSE);
1432         vnfPackageObj.setProvider("huawei");
1433         vnfPackageObj.setOperationalState(EnumOperationalState.ENABLED);
1434         vnfPackageObj.setName("vnf");
1435         vnfPackageObj.setDeletionPending("pending");
1436
1437         String res = vnfPackageObj.getVnfPackageId();
1438         assertEquals("vnfpackageId", res);
1439         res = vnfPackageObj.getVnfPackageUrl();
1440         assertEquals("vnfPackageUrl", res);
1441         res = vnfPackageObj.getVnfd();
1442         assertEquals("vnfd", res);
1443         res = vnfPackageObj.getVersion();
1444         assertEquals("1", res);
1445         EnumUsageState state = vnfPackageObj.getUsageState();
1446         assertEquals(EnumUsageState.NOTINUSE, state);
1447         res = vnfPackageObj.getProvider();
1448         assertEquals("huawei", res);
1449         EnumOperationalState operState = vnfPackageObj.getOperationalState();
1450         assertEquals(EnumOperationalState.ENABLED, operState);
1451         res = vnfPackageObj.getName();
1452         assertEquals("vnf", res);
1453         res = vnfPackageObj.getDeletionPending();
1454         assertEquals("pending", res);
1455     }
1456
1457     @Test
1458     public void testCsarPackageSetter() {
1459         csarPackageObj.setCreateTime("04052017");
1460         csarPackageObj.setDeletionPending("pending");
1461         csarPackageObj.setFormat("format");
1462         csarPackageObj.setId("12");
1463         csarPackageObj.setName("csartest");
1464         csarPackageObj.setSize("10");
1465         csarPackageObj.setStatus("done");
1466         csarPackageObj.setType("type");
1467         csarPackageObj.setUrl("//network");
1468
1469         String res = csarPackageObj.getCreateTime();
1470         assertEquals("04052017", res);
1471         res = csarPackageObj.getDeletionPending();
1472         assertEquals("pending", res);
1473         res = csarPackageObj.getFormat();
1474         assertEquals("format", res);
1475         res = csarPackageObj.getId();
1476         assertEquals("12", res);
1477         res = csarPackageObj.getName();
1478         assertEquals("csartest", res);
1479         res = csarPackageObj.getSize();
1480         assertEquals("10", res);
1481         res = csarPackageObj.getStatus();
1482         assertEquals("done", res);
1483         res = csarPackageObj.getType();
1484         assertEquals("type", res);
1485         res = csarPackageObj.getUrl();
1486         assertEquals("//network", res);
1487
1488     }
1489
1490     @Test
1491     public void testPackageBasicInfoSetter() {
1492         pkgBasicInfoObj.setFormat("pdf");
1493         pkgBasicInfoObj.setProvider("huawei");
1494         pkgBasicInfoObj.setType(EnumType.GSAR);
1495         pkgBasicInfoObj.setVersion("1");
1496         String res = pkgBasicInfoObj.getFormat();
1497         assertEquals("pdf", res);
1498         res = pkgBasicInfoObj.getProvider();
1499         assertEquals("huawei", res);
1500         EnumType type = pkgBasicInfoObj.getType();
1501         assertEquals(EnumType.GSAR, type);
1502         res = pkgBasicInfoObj.getVersion();
1503         assertEquals("1", res);
1504     }
1505
1506     @Test
1507     public void testPackageMetaSetter() {
1508         pkgMetaObj.setCreateTime("05042017");
1509         pkgMetaObj.setCsarId("csarid");
1510         pkgMetaObj.setDeletionPending(true);
1511         pkgMetaObj.setDetails("details");
1512         pkgMetaObj.setDownloadCount(10);
1513         pkgMetaObj.setDownloadUri("//network");
1514         pkgMetaObj.setFormat("pdf");
1515         pkgMetaObj.setModifyTime("05042017");
1516         pkgMetaObj.setName("huawei");
1517         pkgMetaObj.setProvider("huawei");
1518         pkgMetaObj.setRemarks("tested");
1519         pkgMetaObj.setReport("done");
1520         pkgMetaObj.setShortDesc("done");
1521         pkgMetaObj.setSize("1000");
1522         pkgMetaObj.setType("type");
1523         pkgMetaObj.setVersion("1");
1524
1525         String res = pkgMetaObj.getCreateTime();
1526         assertEquals("05042017", res);
1527         res = pkgMetaObj.getCsarId();
1528         assertEquals("csarid", res);
1529         res = pkgMetaObj.getDetails();
1530         assertEquals("details", res);
1531         res = pkgMetaObj.getDownloadCount() + "";
1532         assertEquals("10", res);
1533         res = pkgMetaObj.getDownloadUri();
1534         assertEquals("//network", res);
1535         res = pkgMetaObj.getFormat();
1536         assertEquals("pdf", res);
1537         res = pkgMetaObj.getModifyTime();
1538         assertEquals("05042017", res);
1539         res = pkgMetaObj.getName();
1540         assertEquals("huawei", res);
1541         res = pkgMetaObj.getProvider();
1542         assertEquals("huawei", res);
1543         res = pkgMetaObj.getRemarks();
1544         assertEquals("tested", res);
1545         res = pkgMetaObj.getReport();
1546         assertEquals("done", res);
1547         res = pkgMetaObj.getShortDesc();
1548         assertEquals("done", res);
1549         res = pkgMetaObj.getSize();
1550         assertEquals("1000", res);
1551         res = pkgMetaObj.getType();
1552         assertEquals("type", res);
1553         res = pkgMetaObj.getVersion();
1554         assertEquals("1", res);
1555     }
1556
1557     @Test
1558     public void testPackageResponseSetter() {
1559         pkgResponseObj.setReportPath("localpath");
1560         String res = pkgResponseObj.getReportPath();
1561         assertEquals("localpath", res);
1562
1563     }
1564
1565     @Test
1566     public void testCsarFileUriResSetter() {
1567         csarFileUriResObj.setDownloadUri("downloaduri");
1568         csarFileUriResObj.setLocalPath("localpath");
1569         String res = csarFileUriResObj.getDownloadUri();
1570         assertEquals("downloaduri", res);
1571         res = csarFileUriResObj.getLocalPath();
1572         assertEquals("localpath", res);
1573
1574     }
1575     @Test
1576     public void testGetPackageName() {
1577         String packageName = PackageWrapperUtil.getPackageName("ftpUrl/abc");
1578         assertEquals("/abc", packageName);
1579     }
1580 }