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