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

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