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

   1 /**
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.vnfsdk.marketplace.resource;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertNotNull;
  21 import static org.junit.Assert.assertNull;
  22
  23 import java.io.BufferedInputStream;
  24 import java.io.ByteArrayInputStream;
  25 import java.io.File;
  26 import java.io.FileInputStream;
  27 import java.io.FileNotFoundException;
  28 import java.io.FileOutputStream;
  29 import java.io.FileWriter;
  30 import java.io.IOException;
  31 import java.io.InputStream;
  32 import java.text.DecimalFormat;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.zip.ZipEntry;
  38 import java.util.zip.ZipOutputStream;
  39
  40 import javax.servlet.ReadListener;
  41 import javax.servlet.ServletInputStream;
  42 import javax.servlet.http.HttpServletRequest;
  43 import javax.ws.rs.core.Response;
  44
  45 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.onap.vnfsdk.marketplace.common.FileUtil;
  49 import org.onap.vnfsdk.marketplace.common.ToolUtil;
  50 import org.onap.vnfsdk.marketplace.db.entity.PackageData;
  51 import org.onap.vnfsdk.marketplace.db.impl.MarketplaceDaoImpl;
  52 import org.onap.vnfsdk.marketplace.db.inf.IMarketplaceDao;
  53 import org.onap.vnfsdk.marketplace.db.resource.PackageManager;
  54 import org.onap.vnfsdk.marketplace.db.util.MarketplaceDbUtil;
  55 import org.onap.vnfsdk.marketplace.db.wrapper.PackageHandler;
  56 import org.onap.vnfsdk.marketplace.entity.CsarPackage;
  57 import org.onap.vnfsdk.marketplace.entity.EnumOperationalState;
  58 import org.onap.vnfsdk.marketplace.entity.EnumType;
  59 import org.onap.vnfsdk.marketplace.entity.EnumUsageState;
  60 import org.onap.vnfsdk.marketplace.entity.VnfPackage;
  61 import org.onap.vnfsdk.marketplace.entity.request.PackageBasicInfo;
  62 import org.onap.vnfsdk.marketplace.entity.response.CsarFileUriResponse;
  63 import org.onap.vnfsdk.marketplace.entity.response.PackageMeta;
  64 import org.onap.vnfsdk.marketplace.entity.response.PackageResponse;
  65 import org.onap.vnfsdk.marketplace.filemanage.http.HttpFileManagerImpl;
  66 import org.onap.vnfsdk.marketplace.msb.MsbDetailsHolder;
  67 import org.onap.vnfsdk.marketplace.msb.MsbServer;
  68 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoardingResult;
  69 import org.onap.vnfsdk.marketplace.onboarding.entity.OnBoradingRequest;
  70 import org.onap.vnfsdk.marketplace.onboarding.entity.ResultKey;
  71 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestExceutor;
  72 import org.onap.vnfsdk.marketplace.onboarding.hooks.functiontest.FunctionTestHook;
  73 import org.onap.vnfsdk.marketplace.resource.PackageResource;
  74 import org.onap.vnfsdk.marketplace.rest.RestResponse;
  75 import org.onap.vnfsdk.marketplace.rest.RestfulClient;
  76 import org.onap.vnfsdk.marketplace.wrapper.PackageWrapper;
  77 import org.onap.vnfsdk.marketplace.wrapper.PackageWrapperUtil;
  78 import org.open.infc.grpc.Result;
  79 import org.open.infc.grpc.client.OpenRemoteCli;
  80
  81 import mockit.Mock;
  82 import mockit.MockUp;
  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         assertEquals(res, true);
1150
1151     }
1152
1153     @Test
1154
1155     public void testCreateDirectory() {
1156         String dirPath = "src//test//resources//TestDirectory";
1157         boolean res = FileUtil.createDirectory(dirPath);
1158         assertEquals(res, true);
1159     }
1160
1161     @Test
1162
1163     public void testDeleteDirectory() {
1164         String dirPath = "src//test//resources//TestDirectory";
1165         boolean res = FileUtil.deleteFile(dirPath);
1166         assertEquals(res, true);
1167     }
1168
1169     @Test
1170
1171     public void testGenerateId() {
1172         String id = MarketplaceDbUtil.generateId();
1173         assertNotNull(id);
1174     }
1175
1176     @Test
1177     public void testisNotEmpty() {
1178         boolean res = MarketplaceDbUtil.isNotEmpty(null);
1179         assertEquals(res, false);
1180         res = MarketplaceDbUtil.isNotEmpty("test");
1181         assertEquals(res, true);
1182     }
1183
1184     @Test
1185     public void testobjectToString() {
1186         Object obj = "testexa";
1187         String res = MarketplaceDbUtil.objectToString(obj);
1188         assertNotNull(res);
1189         res = MarketplaceDbUtil.objectToString(null);
1190         assertNull(res);
1191     }
1192
1193     @Test
1194     public void testisEmptyString() {
1195         boolean res = ToolUtil.isEmptyString(null);
1196         assertEquals(res, true);
1197         res = ToolUtil.isEmptyString("huawei");
1198         assertEquals(res, false);
1199     }
1200
1201     @Test
1202     public void testisTrimedEmptyString() {
1203         boolean res = ToolUtil.isTrimedEmptyString(null);
1204         assertEquals(res, true);
1205         res = ToolUtil.isTrimedEmptyString("    ");
1206         assertEquals(res, true);
1207     }
1208
1209     @Test
1210     public void testisEmptyCollection() {
1211
1212         boolean res = ToolUtil.isEmptyCollection(new ArrayList());
1213         assertEquals(res, true);
1214     }
1215
1216     @Test
1217     public void testisYamlFile() {
1218         File fileObj = new File("test.txt");
1219         boolean res = ToolUtil.isYamlFile(fileObj);
1220         assertEquals(res, false);
1221     }
1222
1223     @Test
1224     public void testgenerateID() {
1225         String id = ToolUtil.generateId();
1226         assertNotNull(id);
1227     }
1228
1229     @Test
1230     public void testgetFormatFileSize() {
1231         String res = ToolUtil.getFormatFileSize(10000000);
1232         assertNotNull(res);
1233         res = ToolUtil.getFormatFileSize(10000);
1234         assertNotNull(res);
1235         res = ToolUtil.getFormatFileSize(100);
1236         assertNotNull(res);
1237     }
1238
1239     @Test
1240     public void testObjectToString() {
1241         Object obj = "testexa";
1242         String res = ToolUtil.objectToString(obj);
1243         assertNotNull(res);
1244         res = ToolUtil.objectToString(null);
1245         assertNotNull(res);
1246     }
1247
1248     @Test
1249     public void testprocessFileName() {
1250         String res = ToolUtil.processFileName("abc.txt");
1251         assertNotNull(res);
1252         res = ToolUtil.processFileName("abc.zip");
1253         assertNotNull(res);
1254     }
1255
1256     @Test
1257     public void testremoveCsarSuffix() {
1258         String res = ToolUtil.removeCsarSuffix("abc.csar");
1259         assertEquals(res, "abc");
1260     }
1261
1262     @Test
1263     public void testformatCsar() {
1264         String res = ToolUtil.formatCsar("abc");
1265         assertEquals(res, "abc.csar");
1266     }
1267
1268     @Test
1269     public void testformatFileSize() {
1270         String res = ToolUtil.formatFileSize(10000.0, 10);
1271         String expected = new DecimalFormat("#0.00").format(1000) + "M";// may
1272                                                                         // be
1273                                                                         // "1000.00"
1274                                                                         // or
1275                                                                         // "1000,00"
1276                                                                         // depending
1277                                                                         // on
1278                                                                         // Locale
1279         assertEquals(res, expected);
1280     }
1281
1282     @Test
1283     public void testgetFileSize() {
1284         File fileObj = new File("example.txt");
1285         String res = ToolUtil.getFileSize(fileObj, 10);
1286         assertNotNull(res);
1287     }
1288
1289     @Test
1290     public void testgetCatalogueCsarPath() {
1291         String res = ToolUtil.getCatalogueCsarPath();
1292         assertEquals(res, File.separator + "csar");
1293     }
1294
1295     @Test
1296     public void testgetCatalogueImagePath() {
1297         String res = ToolUtil.getCatalogueImagePath();
1298         assertEquals(res, File.separator + "image");
1299     }
1300
1301     @Test
1302     public void testdeleteFile() {
1303         boolean res = ToolUtil.deleteFile("src//test//resources", "test1.txt");
1304         assertEquals(res, true);
1305     }
1306
1307     @Test
1308     public void teststoreChunkFileInLocal() {
1309         try {
1310             inputStream = new FileInputStream("src//test//resources//Test.txt");
1311             String res = ToolUtil.storeChunkFileInLocal("src//test//resources", "TestOut.txt", inputStream);
1312             File file = new File(res);
1313             String fileName = file.getName();
1314             assertEquals(fileName, "TestOut.txt");
1315
1316         } catch(Exception ex) {
1317             ex.printStackTrace();
1318         }
1319     }
1320
1321     @Test
1322     public void testToolUtildeleteFile() {
1323         boolean res = ToolUtil.deleteFile("src/test/resources", "TestOut.txt");
1324         assertEquals(res, true);
1325     }
1326
1327
1328     @Test
1329     public void testUnzip() {
1330
1331         List<String> listObj = new ArrayList<String>();
1332         try {
1333             listObj = FileUtil.unzip("src/test/resources/temp.zip", "src/test/resources/testfolder");
1334         } catch(Exception ex) {
1335             ex.printStackTrace();
1336         }
1337         assertNotNull(listObj);
1338     }
1339
1340     @Test
1341     public void testreadJsonDatafFromFile() {
1342
1343         Object obj =
1344                 FileUtil.readJsonDatafFromFile("src/main/resources/generalconfig/OnBoardingSteps.json", Object.class);
1345         assertNotNull(obj);
1346     }
1347
1348     @Test
1349     public void testGetPkgSize() {
1350         long pkgSize = PackageWrapperUtil.getPacakgeSize("src/test/resources/Test.txt");
1351         assertNotNull(pkgSize);
1352     }
1353
1354     @Test
1355     public void testPkgFormat() {
1356         assertNotNull(PackageWrapperUtil.getPackageFormat("xml"));
1357         assertNotNull(PackageWrapperUtil.getPackageFormat("yml"));
1358         assertNull(PackageWrapperUtil.getPackageFormat("pdf"));
1359
1360         MsbDetailsHolder.getMsbDetails();
1361         try {
1362             IMarketplaceDao dao = new MarketplaceDaoImpl();
1363
1364             packageDataList = new ArrayList<PackageData>();
1365             packageData = new PackageData();
1366             packageData.setCsarId("21");
1367             packageData.setDownloadUri("src\\test\\resources\\");
1368             packageData.setName("clearwater_ns.csar");
1369             packageData.setSize("59,854  bytes");
1370             packageData.setVersion("v1.0");
1371             packageData.setProvider("Huawei");
1372             packageDataList.add(packageData);
1373
1374             dao.savePackageData(packageData);
1375             dao.getAllPackageData();
1376             dao.getPackageData("21");
1377             dao.updatePackageData(packageData);
1378             dao.deletePackageData("21");
1379
1380         } catch(Exception e) {
1381         }
1382
1383     }
1384
1385     @Test
1386     public void testVnfPackageSetter() {
1387
1388         vnfPackageObj.setVnfPackageId("vnfpackageId");
1389         vnfPackageObj.setVnfPackageUrl("vnfPackageUrl");
1390         vnfPackageObj.setVnfd("vnfd");
1391         vnfPackageObj.setVersion("1");
1392         vnfPackageObj.setUsageState(EnumUsageState.NotInUse);
1393         vnfPackageObj.setProvider("huawei");
1394         vnfPackageObj.setOperationalState(EnumOperationalState.Enabled);
1395         vnfPackageObj.setName("vnf");
1396         vnfPackageObj.setDeletionPending("pending");
1397
1398         String res = vnfPackageObj.getVnfPackageId();
1399         assertEquals(res, "vnfpackageId");
1400         res = vnfPackageObj.getVnfPackageUrl();
1401         assertEquals(res, "vnfPackageUrl");
1402         res = vnfPackageObj.getVnfd();
1403         assertEquals(res, "vnfd");
1404         res = vnfPackageObj.getVersion();
1405         assertEquals(res, "1");
1406         EnumUsageState state = vnfPackageObj.getUsageState();
1407         assertEquals(state, EnumUsageState.NotInUse);
1408         res = vnfPackageObj.getProvider();
1409         assertEquals(res, "huawei");
1410         EnumOperationalState operState = vnfPackageObj.getOperationalState();
1411         assertEquals(operState, EnumOperationalState.Enabled);
1412         res = vnfPackageObj.getName();
1413         assertEquals(res, "vnf");
1414         res = vnfPackageObj.getDeletionPending();
1415         assertEquals(res, "pending");
1416     }
1417
1418     @Test
1419     public void testCsarPackageSetter() {
1420         csarPackageObj.setCreateTime("04052017");
1421         csarPackageObj.setDeletionPending("pending");
1422         csarPackageObj.setFormat("format");
1423         csarPackageObj.setId("12");
1424         csarPackageObj.setName("csartest");
1425         csarPackageObj.setSize("10");
1426         csarPackageObj.setStatus("done");
1427         csarPackageObj.setType("type");
1428         csarPackageObj.setUrl("//network");
1429
1430         String res = csarPackageObj.getCreateTime();
1431         assertEquals(res, "04052017");
1432         res = csarPackageObj.getDeletionPending();
1433         assertEquals(res, "pending");
1434         res = csarPackageObj.getFormat();
1435         assertEquals(res, "format");
1436         res = csarPackageObj.getId();
1437         assertEquals(res, "12");
1438         res = csarPackageObj.getName();
1439         assertEquals(res, "csartest");
1440         res = csarPackageObj.getSize();
1441         assertEquals(res, "10");
1442         res = csarPackageObj.getStatus();
1443         assertEquals(res, "done");
1444         res = csarPackageObj.getType();
1445         assertEquals(res, "type");
1446         res = csarPackageObj.getUrl();
1447         assertEquals(res, "//network");
1448
1449     }
1450
1451     @Test
1452     public void testPackageBasicInfoSetter() {
1453         pkgBasicInfoObj.setFormat("pdf");
1454         pkgBasicInfoObj.setProvider("huawei");
1455         pkgBasicInfoObj.setType(EnumType.GSAR);
1456         pkgBasicInfoObj.setVersion("1");
1457         String res = pkgBasicInfoObj.getFormat();
1458         assertEquals(res, "pdf");
1459         res = pkgBasicInfoObj.getProvider();
1460         assertEquals(res, "huawei");
1461         EnumType type = pkgBasicInfoObj.getType();
1462         assertEquals(type, EnumType.GSAR);
1463         res = pkgBasicInfoObj.getVersion();
1464         assertEquals(res, "1");
1465     }
1466
1467     @Test
1468     public void testPackageMetaSetter() {
1469         pkgMetaObj.setCreateTime("05042017");
1470         pkgMetaObj.setCsarId("csarid");
1471         pkgMetaObj.setDeletionPending(true);
1472         pkgMetaObj.setDetails("details");
1473         pkgMetaObj.setDownloadCount(10);
1474         pkgMetaObj.setDownloadUri("//network");
1475         pkgMetaObj.setFormat("pdf");
1476         pkgMetaObj.setModifyTime("05042017");
1477         pkgMetaObj.setName("huawei");
1478         pkgMetaObj.setProvider("huawei");
1479         pkgMetaObj.setRemarks("tested");
1480         pkgMetaObj.setReport("done");
1481         pkgMetaObj.setShortDesc("done");
1482         pkgMetaObj.setSize("1000");
1483         pkgMetaObj.setType("type");
1484         pkgMetaObj.setVersion("1");
1485
1486         String res = pkgMetaObj.getCreateTime();
1487         assertEquals(res, "05042017");
1488         res = pkgMetaObj.getCsarId();
1489         assertEquals(res, "csarid");
1490         res = pkgMetaObj.getDetails();
1491         assertEquals(res, "details");
1492         res = pkgMetaObj.getDownloadCount() + "";
1493         assertEquals(res, "10");
1494         res = pkgMetaObj.getDownloadUri();
1495         assertEquals(res, "//network");
1496         res = pkgMetaObj.getFormat();
1497         assertEquals(res, "pdf");
1498         res = pkgMetaObj.getModifyTime();
1499         assertEquals(res, "05042017");
1500         res = pkgMetaObj.getName();
1501         assertEquals(res, "huawei");
1502         res = pkgMetaObj.getProvider();
1503         assertEquals(res, "huawei");
1504         res = pkgMetaObj.getRemarks();
1505         assertEquals(res, "tested");
1506         res = pkgMetaObj.getReport();
1507         assertEquals(res, "done");
1508         res = pkgMetaObj.getShortDesc();
1509         assertEquals(res, "done");
1510         res = pkgMetaObj.getSize();
1511         assertEquals(res, "1000");
1512         res = pkgMetaObj.getType();
1513         assertEquals(res, "type");
1514         res = pkgMetaObj.getVersion();
1515         assertEquals(res, "1");
1516     }
1517
1518     @Test
1519     public void testPackageResponseSetter() {
1520         pkgResponseObj.setReportPath("localpath");
1521         String res = pkgResponseObj.getReportPath();
1522         assertEquals(res, "localpath");
1523
1524     }
1525
1526     @Test
1527     public void testCsarFileUriResSetter() {
1528         csarFileUriResObj.setDownloadUri("downloaduri");
1529         csarFileUriResObj.setLocalPath("localpath");
1530         String res = csarFileUriResObj.getDownloadUri();
1531         assertEquals(res, "downloaduri");
1532         res = csarFileUriResObj.getLocalPath();
1533         assertEquals(res, "localpath");
1534
1535     }
1536 }