huawei/vnfmadapter/VnfmadapterService/service/src/test/java/org/onap/vfc/nfvo/vnfm/svnfm/vnfmadapter/service/adapter/impl/AdapterResourceManagerTest.java

   1 /*
   2  * Copyright 2016-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.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.adapter.impl;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertTrue;
  21
  22 import java.io.IOException;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25
  26 import org.apache.commons.httpclient.HttpClient;
  27 import org.apache.commons.httpclient.HttpMethod;
  28 import org.apache.commons.httpclient.HttpMethodBase;
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.DownloadCsarManager;
  32 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
  33 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.RestfulParametes;
  34 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.RestfulResponse;
  35 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.servicetoken.VNFRestfulUtil;
  36 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.servicetoken.VnfmRestfulUtil;
  37 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.csm.connect.ConnectMgrVnfm;
  38 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.testutils.JsonUtil;
  39
  40 import mockit.Mock;
  41 import mockit.MockUp;
  42 import net.sf.json.JSONArray;
  43 import net.sf.json.JSONException;
  44 import net.sf.json.JSONObject;
  45
  46 public class AdapterResourceManagerTest {
  47
  48     AdapterResourceManager manager = null;
  49
  50     @Before
  51     public void setUp() {
  52         manager = new AdapterResourceManager();
  53     }
  54
  55     @Test(expected=JSONException.class)
  56     public void uploadVNFPackageTestJsonException() {
  57         JSONObject vnfpkg = new JSONObject();
  58         Map<String, String> paramsMap = new HashMap<>();
  59         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
  60     }
  61
  62      @Test
  63     public void uploadVNFPackageTestJsonException1() {
  64         JSONObject vnfpkg = new JSONObject();
  65         vnfpkg.put("", "");
  66         Map<String, String> paramsMap = new HashMap<>();
  67         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
  68     }
  69
  70     @Test(expected=JSONException.class)
  71     public void uploadVNFPackageTestJsonException2() {
  72         Map<String, String> paramsMap = new HashMap<>();
  73          manager.uploadVNFPackage(null, paramsMap);
  74     }
  75
  76     @Test
  77     public void uploadVNFPackageTestJsonException3() {
  78         JSONObject vnfpkg = new JSONObject();
  79         vnfpkg.put("name", "test");
  80         Map<String, String> paramsMap = new HashMap<>();
  81         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
  82         assertTrue(res.get("reason").equals("csarid and vnfmid are null."));
  83
  84     }
  85
  86     @Test
  87     public void uploadVNFPackageTestEmptyParam() {
  88         JSONObject vnfpkg = new JSONObject();
  89         vnfpkg.put("name", "test");
  90         Map<String, String> paramsMap = new HashMap<>();
  91         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
  92         assertTrue(res.get("reason").equals("csarid and vnfmid are null."));
  93
  94     }
  95
  96     @Test(expected=NullPointerException.class)
  97     public void uploadVNFPackageTestNullParam() {
  98         JSONObject vnfpkg = new JSONObject();
  99         vnfpkg.put("name", "test");
 100         JSONObject res = manager.uploadVNFPackage(vnfpkg, null);
 101         assertTrue(res.get("reason").equals("csarid and vnfmid are null."));
 102
 103     }
 104
 105     @Test
 106     public void uploadVNFPackageTestInvalidCsrid() {
 107         JSONObject vnfpkg = new JSONObject();
 108         vnfpkg.put("name", "test");
 109         Map<String, String> paramsMap = new HashMap<>();
 110         paramsMap.put("csarid", "");
 111         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 112         assertTrue(res.get("reason").equals("csarid is null."));
 113
 114     }
 115
 116     @Test
 117     public void uploadVNFPackageTestInvalidCsrid2() {
 118         JSONObject vnfpkg = new JSONObject();
 119         vnfpkg.put("name", "test");
 120         Map<String, String> paramsMap = new HashMap<>();
 121         paramsMap.put("csarid", null);
 122         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 123         assertTrue(res.get("reason").equals("csarid is null."));
 124
 125     }
 126
 127     @Test
 128     public void uploadVNFPackageTestInvalidVnfmid() {
 129         JSONObject vnfpkg = new JSONObject();
 130         vnfpkg.put("name", "test");
 131         Map<String, String> paramsMap = new HashMap<>();
 132         paramsMap.put("csarid", "csarid123");
 133         paramsMap.put("vnfmid", null);
 134         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 135         assertTrue(res.get("reason").equals("vnfmid is null."));
 136
 137     }
 138
 139     @Test
 140     public void uploadVNFPackageTestInvalidVnfmid2() {
 141         JSONObject vnfpkg = new JSONObject();
 142         vnfpkg.put("name", "test");
 143         Map<String, String> paramsMap = new HashMap<>();
 144         paramsMap.put("csarid", "csarid123");
 145         paramsMap.put("vnfmid", "");
 146         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 147         assertTrue(res.get("reason").equals("vnfmid is null."));
 148
 149     }
 150
 151     @Test
 152     public void uploadVNFPackageTestNullResp() {
 153         JSONObject vnfpkg = new JSONObject();
 154         vnfpkg.put("name", "test");
 155         Map<String, String> paramsMap = new HashMap<>();
 156         paramsMap.put("csarid", "csarid123");
 157         paramsMap.put("vnfmid", "vnfmid1234");
 158         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 159         assertTrue(res.get("reason").equals("RestfulResponse is null."));
 160
 161     }
 162
 163     @Test
 164     public void downloadCsarTestNullUrl() {
 165         String url = null;
 166         String filePath = null;
 167         JSONObject res = manager.downloadCsar(url, filePath);
 168         assertTrue(res.get("reason").equals("url is null."));
 169     }
 170
 171     @Test
 172     public void downloadCsarTestEmptyUrl() {
 173         String url = "";
 174         String filePath = null;
 175         JSONObject res = manager.downloadCsar(url, filePath);
 176         assertTrue(res.get("reason").equals("url is null."));
 177     }
 178
 179     @Test
 180     public void downloadCsarTestNullFilePath() {
 181         String url = "http://localhost:8080";
 182         String filePath = null;
 183         JSONObject res = manager.downloadCsar(url, filePath);
 184         assertTrue(res.get("reason").equals("downloadUrl filePath is null."));
 185     }
 186
 187     @Test
 188     public void downloadCsarTestEmptyFilePath() {
 189         String url = "http://localhost:8080";
 190         String filePath = "";
 191         JSONObject res = manager.downloadCsar(url, filePath);
 192         assertTrue(res.get("reason").equals("downloadUrl filePath is null."));
 193     }
 194
 195     @Test
 196     public void getVnfmConnInfoTestSuccess() {
 197         new MockUp<VNFRestfulUtil>() {
 198
 199             @Mock
 200             public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 201                 RestfulResponse resp = new RestfulResponse();
 202                 resp.setStatus(200);
 203                 Map<String, String> objMap = new HashMap<String, String>();
 204                 objMap.put("id", "test123");
 205
 206                 String responseString = toJson(objMap);
 207                 resp.setResponseJson(responseString);
 208                 return resp;
 209             }
 210
 211         };
 212         Map<String, String> paramsMap = new HashMap<String, String>();
 213         JSONObject res = manager.getVnfmConnInfo(paramsMap);
 214         assertTrue(res.get("id").equals("test123"));
 215     }
 216
 217     @Test
 218     public void getVnfmConnInfoTestNullResp() {
 219         new MockUp<VNFRestfulUtil>() {
 220
 221             @Mock
 222             public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 223
 224                 return null;
 225             }
 226
 227         };
 228         Map<String, String> paramsMap = new HashMap<String, String>();
 229         JSONObject res = manager.getVnfmConnInfo(paramsMap);
 230         assertTrue(res.get("reason").equals("RestfulResponse is null."));
 231     }
 232
 233     @Test
 234     public void getVnfmConnInfoTestServerError() {
 235         new MockUp<VNFRestfulUtil>() {
 236
 237             @Mock
 238             public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 239                 RestfulResponse resp = new RestfulResponse();
 240                 resp.setStatus(500);
 241                 Map<String, String> objMap = new HashMap<String, String>();
 242                 objMap.put("id", "test123");
 243
 244                 String responseString = toJson(objMap);
 245                 resp.setResponseJson(responseString);
 246                 return resp;
 247             }
 248
 249         };
 250         Map<String, String> paramsMap = new HashMap<String, String>();
 251         JSONObject res = manager.getVnfmConnInfo(paramsMap);
 252         assertTrue(res.get("reason").equals("ESR return fail."));
 253     }
 254
 255     @Test
 256     public void uploadTestInternalError() {
 257         JSONObject vnfpackage = new JSONObject();
 258         String vnfmurl = "http://localhost";
 259         String conntoken = "test";
 260         JSONObject res = manager.upload(vnfpackage, vnfmurl, conntoken);
 261         assertEquals(res.get("retCode"), 500);
 262     }
 263
 264     public static String toJson(Map o) {
 265         try {
 266             return JsonUtil.marshal(o);
 267         } catch(IOException e) {
 268             return "";
 269         }
 270     }
 271
 272     @Test
 273     public void testGetAllCloud(){
 274         String url = null;
 275         manager.getAllCloud(url,null);
 276     }
 277
 278     @Test
 279     public void testGetAllCloud2(){
 280         String url = "http://127.0.0.1:31943";
 281         manager.getAllCloud(url,null);
 282     }
 283     @Test
 284     public void testUnzipCSAR(){
 285         manager.unzipCSAR(null,null);
 286     }
 287     @Test
 288     public void testUnzipCSAR2(){
 289         manager.unzipCSAR("vCpe.zip",null);
 290     }
 291     @Test
 292     public void testUnzipCSAR3(){
 293         manager.unzipCSAR("vCpe.zip","/opt");
 294     }
 295     @Test
 296     public void testUnzipCSAR4(){
 297         new MockUp<DownloadCsarManager>(){
 298             @Mock
 299             public  int unzipCSAR(String fileName,String filePath){
 300                 return 0;
 301             }
 302         };
 303         manager.unzipCSAR("vCpe.zip","/opt");
 304     }
 305     @Test
 306     public void testUnzipCSAR5(){
 307         new MockUp<DownloadCsarManager>(){
 308             @Mock
 309             public  int unzipCSAR(String fileName,String filePath){
 310                 return -1;
 311             }
 312         };
 313         manager.unzipCSAR("vCpe.zip","/opt");
 314     }
 315
 316     @Test
 317     public void testGetVnfdVersion(){
 318         manager.getVnfdVersion("http://","127.0.0.1","token");
 319     }
 320
 321     @Test(expected=NullPointerException.class)
 322     public void testgetVNFDPlanInfoNull(){
 323
 324         manager.getVNFDPlanInfo(null, null, null);
 325         }
 326
 327     @Test
 328     public void testgetVNFDPlanInfo(){
 329
 330         manager.getVNFDPlanInfo("https://127.0.0.1:80", "vnfd123", "token");
 331         }
 332
 333     @Test
 334     public void testgetVNFDPlanInfoConn(){
 335
 336         new MockUp<HttpClient>(){
 337                 @Mock
 338                 public int executeMethod(HttpMethod method) {
 339                     return 200;
 340                 }
 341             };
 342
 343             new MockUp<HttpMethodBase>(){
 344
 345                 @Mock
 346                  public int getStatusCode(){
 347
 348                         return 200;
 349                 }
 350
 351                 @Mock
 352                  public String getResponseBodyAsString()
 353                                    throws IOException
 354                                   {
 355                         JSONObject jobj = new JSONObject();
 356                         jobj.put("Status", 200);
 357                         jobj.put("UserName", "User");
 358                         jobj.put("password", "pass");
 359                         String str = jobj.toString();
 360                         return str;
 361                                    }
 362
 363             };
 364
 365         manager.getVNFDPlanInfo("https://127.0.0.1:80", "vnfd123", "accessSession");
 366         }
 367
 368     @Test
 369     public void testgetVNFDPlanInfoConn500(){
 370
 371         new MockUp<HttpClient>(){
 372                 @Mock
 373                 public int executeMethod(HttpMethod method) {
 374                     return 200;
 375                 }
 376             };
 377
 378             new MockUp<HttpMethodBase>(){
 379
 380                 @Mock
 381                  public int getStatusCode(){
 382
 383                         return 500;
 384                 }
 385
 386                  @Mock
 387                  public String getResponseBodyAsString()
 388                                    throws IOException
 389                                   {
 390                         String str = "Failed";
 391                         return str;
 392                                    }
 393
 394             };
 395
 396         manager.getVNFDPlanInfo("https://127.0.0.1:80", "vnfd123", "accessSession");
 397         }
 398
 399
 400     @Test
 401     public void testGetVnfdVersion200(){
 402
 403         new MockUp<HttpClient>(){
 404                 @Mock
 405                 public int executeMethod(HttpMethod method) {
 406                     return 200;
 407                 }
 408             };
 409
 410             new MockUp<HttpMethodBase>(){
 411
 412                 @Mock
 413                  public int getStatusCode(){
 414
 415                         return 200;
 416                 }
 417
 418                 @Mock
 419                  public String getResponseBodyAsString()
 420                                    throws IOException
 421                                   {
 422                         JSONObject jobj = new JSONObject();
 423                         jobj.put("Status", 200);
 424                         jobj.put("UserName", "User");
 425                         jobj.put("password", "pass");
 426                         String str = jobj.toString();
 427                         return str;
 428                                    }
 429
 430             };
 431
 432             JSONObject jobj = manager.getVnfdVersion("http://","127.0.0.1:80","accessSession");
 433     }
 434
 435     @Test
 436     public void testGetVnfdVersion500(){
 437
 438         new MockUp<HttpClient>(){
 439                 @Mock
 440                 public int executeMethod(HttpMethod method) {
 441                     return 200;
 442                 }
 443             };
 444
 445             new MockUp<HttpMethodBase>(){
 446
 447                 @Mock
 448                  public int getStatusCode(){
 449
 450                         return 500;
 451                 }
 452
 453             @Mock
 454          public String getResponseBodyAsString()
 455                            throws IOException
 456                           {
 457                 String str = "Failed";
 458                 return str;
 459                            }
 460             };
 461
 462         manager.getVnfdVersion("http://","127.0.0.1:80","accessSession");
 463     }
 464
 465     @Test
 466     public void uploadVNFPackageTestcsarid() {
 467          RestfulParametes rp = new RestfulParametes();
 468          rp.setRawData("success");
 469          rp.setRawData("sdjhbfj");
 470          HashMap<String,String>  headerMap = new HashMap<String,String>();
 471          headerMap.put("Content-Type", "application/json");
 472          headerMap.put("X-TransactionId", "5851");
 473          rp.setHeaderMap(headerMap);
 474          HashMap<String,String>  paramMap = new HashMap<String,String>();
 475          paramMap.put("id", "1234");
 476          rp.setParamMap(paramMap);
 477         JSONObject vnfpkg = new JSONObject();
 478         vnfpkg.put("name", "test");
 479         vnfpkg.put("Restfulparameters", rp);
 480         Map<String, String> paramsMap = new HashMap<>();
 481         paramsMap.put("csarid", "csarid200");
 482         paramsMap.put("vnfmid", "vnfmid1234");
 483         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 484         assertTrue(res.get("reason").equals("RestfulResponse is null."));
 485     }
 486
 487     @Test
 488     public void uploadVNFPackageTestcsaridNull() {
 489         JSONObject vnfpkg = new JSONObject();
 490         vnfpkg.put("name", "test");
 491         Map<String, String> paramsMap = new HashMap<>();
 492         paramsMap.put("csarid", "caser200");
 493         paramsMap.put("vnfmid", "vnfmid1234");
 494         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 495         assertTrue(res.get("reason").equals("RestfulResponse is null."));
 496
 497     }
 498
 499     @Test
 500     public void uploadVNFPackageTestParamEmpty() {
 501         JSONObject vnfpkg = new JSONObject();
 502         vnfpkg.put("name", "test");
 503         Map<String, String> paramsMap = new HashMap<>();
 504         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 505     }
 506
 507     @Test
 508     public void downloadCsarTestUrlAndFilePathWrong() {
 509         String url = "http://localhost:8080";
 510         String filePath = "Tset";
 511         JSONObject res = manager.downloadCsar(url, filePath);
 512     }
 513     @Test
 514     public void downloadCsarTestUrlAndFilePath() {
 515         String url = "https://127.0.0.1:31943";
 516         String filePath = "src/test/resources/Check.txt";
 517         JSONObject res = manager.downloadCsar(url, filePath);
 518     }
 519
 520     @Test
 521     public void testGetAllCloudUrlEmpty(){
 522         String url = "";
 523         manager.getAllCloud(url,null);
 524     }
 525
 526     @Test
 527     public void testGetAllCloudUrlandConn(){
 528         String url = "http://127.0.0.1:31943";
 529         String conn = "conn";
 530         manager.getAllCloud(url,conn);
 531     }
 532
 533     @Test
 534     public void testUnzipCSAREmpty(){
 535         manager.unzipCSAR("vCpe.zip","");
 536     }
 537     @Test
 538     public void testUnzipCSAREmpty1(){
 539         manager.unzipCSAR("","/opt");
 540     }
 541
 542     @Test
 543     public void readVfnPkgInfoFromJsonTest() throws IOException{
 544
 545         System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
 546         AdapterResourceManager.readVfnPkgInfoFromJson();
 547     }
 548     @Test
 549     public void readVfnPkgInfoFromJsonTestNumBelowZero() throws IOException{
 550
 551         System.setProperty("catalina.base", "C:/Users/Huawei/Desktop");
 552         AdapterResourceManager.readVfnPkgInfoFromJson();
 553     }
 554
 555     @Test
 556     public void testGetAllCloudUrlandaccessSession(){
 557
 558         new MockUp<HttpClient>(){
 559                 @Mock
 560                 public int executeMethod(HttpMethod method) {
 561                     return 200;
 562                 }
 563             };
 564
 565             new MockUp<HttpMethodBase>(){
 566
 567                 @Mock
 568                  public int getStatusCode(){
 569
 570                         return 200;
 571                 }
 572
 573                 @Mock
 574                  public String getResponseBodyAsString()
 575                                    throws IOException
 576                                   {
 577                         String str = "{\n\t\"driverInfo\": {\n\t\t\"driverName\": \"hwvnfm\",\n\t\t\"instanceID\": \"hwvnfm-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\"services\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\"support_sys\": [{\n\t\t\t\t\"type\": \"vnfm\",\n\t\t\t\t\"version\": \"V100R001\"\n\t\t\t}]\n\t\t}]\n\t}\n}";
 578                         JSONObject jobj = new JSONObject();
 579                         jobj.put("Status", 200);
 580                         jobj.put("UserName", "User");
 581                         jobj.put("password", "pass");
 582                         JSONArray ja = new JSONArray();
 583                         ja.add(str);
 584                         jobj.put("vim_info", ja);
 585                         String str1 = jobj.toString();
 586                         return str1;
 587                                    }
 588
 589             };
 590
 591             System.setProperty("catalina.base", "C:/Users/Huawei/Desktop");
 592         String url = "http://127.0.0.1:31943";
 593         String conn = "accessSession";
 594         manager.getAllCloud(url,conn);
 595     }
 596
 597     @Test
 598     public void testGetAllCloudUrlandaccessSession500(){
 599
 600         new MockUp<HttpClient>(){
 601                 @Mock
 602                 public int executeMethod(HttpMethod method) {
 603                     return 200;
 604                 }
 605             };
 606
 607             new MockUp<HttpMethodBase>(){
 608
 609                 @Mock
 610                  public int getStatusCode(){
 611
 612                         return 500;
 613                 }
 614
 615                 @Mock
 616                  public String getResponseBodyAsString()
 617                                    throws IOException
 618                                   {
 619                         String str = "Failed";
 620                         return str;
 621                                    }
 622
 623             };
 624
 625             System.setProperty("catalina.base", "C:/Users/Huawei/Desktop");
 626         String url = "http://127.0.0.1:31943";
 627         String conn = "accessSession";
 628         manager.getAllCloud(url,conn);
 629     }
 630
 631     @Test
 632     public void testUpload(){
 633
 634         new MockUp<HttpClient>(){
 635                 @Mock
 636                 public int executeMethod(HttpMethod method) {
 637                     return 200;
 638                 }
 639             };
 640
 641             new MockUp<HttpMethodBase>(){
 642
 643                 @Mock
 644                  public int getStatusCode(){
 645
 646                         return 200;
 647                 }
 648
 649                 @Mock
 650                  public String getResponseBodyAsString()
 651                                    throws IOException
 652                                   {
 653                         JSONObject jobj = new JSONObject();
 654                         jobj.put("Status", 200);
 655                         jobj.put("UserName", "User");
 656                         jobj.put("password", "pass");
 657                         String str = jobj.toString();
 658                         return str;
 659                                    }
 660
 661             };
 662
 663         JSONObject vnfpackage = new JSONObject();
 664         vnfpackage.put("UserName", "User");
 665         vnfpackage.put("password", "Pass");
 666         String vnfmurl = "http://127.0.0.1:31943";
 667           String conntoken = "accessSession";
 668           System.setProperty("catalina.base", "src/test/resources/");
 669         manager.upload(vnfpackage, vnfmurl, conntoken);
 670     }
 671
 672     @Test
 673     public void testUploadNoJson(){
 674
 675         new MockUp<HttpClient>(){
 676                 @Mock
 677                 public int executeMethod(HttpMethod method) {
 678                     return 200;
 679                 }
 680             };
 681
 682             new MockUp<HttpMethodBase>(){
 683
 684                 @Mock
 685                  public int getStatusCode(){
 686
 687                         return 200;
 688                 }
 689
 690                 @Mock
 691                  public String getResponseBodyAsString()
 692                                    throws IOException
 693                                   {
 694
 695                         String str = "Test";
 696                         return str;
 697                                    }
 698
 699             };
 700
 701         JSONObject vnfpackage = new JSONObject();
 702         vnfpackage.put("UserName", "User");
 703         vnfpackage.put("password", "Pass");
 704         String vnfmurl = "http://127.0.0.1:31943";
 705           String conntoken = "accessSession";
 706           System.setProperty("catalina.base", "src/test/resources/");
 707         manager.upload(vnfpackage, vnfmurl, conntoken);
 708     }
 709
 710     @Test
 711     public void testUpload500(){
 712
 713         new MockUp<HttpClient>(){
 714                 @Mock
 715                 public int executeMethod(HttpMethod method) {
 716                     return 200;
 717                 }
 718             };
 719
 720             new MockUp<HttpMethodBase>(){
 721
 722                 @Mock
 723                  public int getStatusCode(){
 724
 725                         return 500;
 726                 }
 727
 728                 @Mock
 729                  public String getResponseBodyAsString()
 730                                    throws IOException
 731                                   {
 732                         String str = "Failed";
 733                         return str;
 734                                    }
 735
 736             };
 737
 738         JSONObject vnfpackage = new JSONObject();
 739         vnfpackage.put("UserName", "User");
 740         vnfpackage.put("password", "Pass");
 741         String vnfmurl = "http://127.0.0.1:31943";
 742           String conntoken = "accessSession";
 743           System.setProperty("catalina.base", "src/test/resources/");
 744         manager.upload(vnfpackage, vnfmurl, conntoken);
 745     }
 746
 747     @Test
 748     public void testGetVnfmCsarInfoEmpty(){
 749         manager.getVnfmCsarInfo("");
 750     }
 751     @Test
 752     public void testGetVnfmCsarInfoNull(){
 753         manager.getVnfmCsarInfo(null);
 754     }
 755     /*@Test
 756     public void testGetVnfmCsarInfo(){
 757         manager.getVnfmCsarInfo("casr-id-123");
 758     }*/
 759     @Test
 760     public void downloadCsarTest() {
 761
 762         new MockUp<DownloadCsarManager>(){
 763         @Mock
 764         public String download(String url, String filepath) {
 765                         return "Success";
 766
 767         }
 768         };
 769
 770         String url = "http://localhost:8080";
 771         String filePath = "src/test/resources/Check.txt";
 772         JSONObject res = manager.downloadCsar(url, filePath);
 773         assertTrue(true);
 774     }
 775
 776     @Test(expected=JSONException.class)
 777     public void uploadVNFPackageTest() {
 778
 779         new MockUp<VNFRestfulUtil>(){
 780                 @Mock
 781                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 782                         RestfulResponse rr = new RestfulResponse();
 783                         Map<String, String> header = new HashMap<>();
 784                         header.put("Content-Type", "Application/Json");
 785                         header.put("X-FormId", "jhfdl");
 786                         rr.setRespHeaderMap(header);
 787                         rr.setStatus(200);
 788                         rr.setResponseJson("shdfhj");
 789
 790                         return rr;
 791
 792                 }
 793         };
 794
 795         new MockUp<RestfulResponse>(){
 796
 797                 @Mock
 798                  public String getResponseContent() {
 799
 800                                 return "Success";
 801                  }
 802
 803         };
 804
 805         new MockUp<JSONObject>(){
 806         @Mock
 807         public JSONObject fromObject(Object object){
 808                 JSONObject js = new JSONObject();
 809                 js.put("Result", "Success");
 810                 js.put("Check", "Ok");
 811                 js.put("downloadUri", "http://127.0.0.1:80");
 812                 return js;
 813         }
 814         };
 815
 816         JSONObject vnfpkg = new JSONObject();
 817         vnfpkg.put("name", "test");
 818         JSONObject obj = new JSONObject();
 819         obj.put("csar_file_path", "src/test/resources/Check10.txt");
 820         obj.put("csar_file_name", "casrFile");
 821         vnfpkg.put("template", obj);
 822         Map<String, String> paramsMap = new HashMap<>();
 823         paramsMap.put("csarid", "csarid123");
 824         paramsMap.put("vnfmid", "vnfmid1234");
 825         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 826         assertTrue(true);
 827
 828     }
 829
 830     @Test(expected=JSONException.class)
 831     public void uploadVNFPackageTestSuccess() {
 832
 833         new MockUp<VNFRestfulUtil>(){
 834                 @Mock
 835                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 836                         RestfulResponse rr = new RestfulResponse();
 837                         Map<String, String> header = new HashMap<>();
 838                         header.put("Content-Type", "Application/Json");
 839                         header.put("X-FormId", "jhfdl");
 840                         rr.setRespHeaderMap(header);
 841                         rr.setStatus(200);
 842                         rr.setResponseJson("shdfhj");
 843
 844                         return rr;
 845
 846                 }
 847         };
 848
 849         new MockUp<RestfulResponse>(){
 850
 851                 @Mock
 852                  public String getResponseContent() {
 853
 854                                 return "Success";
 855                  }
 856
 857         };
 858
 859         new MockUp<JSONObject>(){
 860         @Mock
 861         public JSONObject fromObject(Object object){
 862                 JSONObject js = new JSONObject();
 863                 js.put("Result", "Success");
 864                 js.put("Check", "Ok");
 865                 js.put("downloadUri", "http://127.0.0.1:80");
 866                 return js;
 867         }
 868         };
 869
 870         new MockUp<DownloadCsarManager>(){
 871                 @Mock
 872                 public String download(String url, String filepath) {
 873                         return "Success";
 874
 875                 }
 876                 };
 877
 878         JSONObject vnfpkg = new JSONObject();
 879         vnfpkg.put("name", "test");
 880         JSONObject obj = new JSONObject();
 881         obj.put("csar_file_path", "src/test/resources/Check10.txt");
 882         obj.put("csar_file_name", "casrFile");
 883         vnfpkg.put("template", obj);
 884         Map<String, String> paramsMap = new HashMap<>();
 885         paramsMap.put("csarid", "csarid123");
 886         paramsMap.put("vnfmid", "vnfmid1234");
 887         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 888         assertTrue(true);
 889
 890     }
 891
 892     @Test(expected=JSONException.class)
 893     public void uploadVNFPackageTestSuccessUNZIP() {
 894
 895         new MockUp<VNFRestfulUtil>(){
 896                 @Mock
 897                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 898                         RestfulResponse rr = new RestfulResponse();
 899                         Map<String, String> header = new HashMap<>();
 900                         header.put("Content-Type", "Application/Json");
 901                         header.put("X-FormId", "jhfdl");
 902                         rr.setRespHeaderMap(header);
 903                         rr.setStatus(200);
 904                         rr.setResponseJson("shdfhj");
 905
 906                         return rr;
 907
 908                 }
 909         };
 910
 911         new MockUp<RestfulResponse>(){
 912
 913                 @Mock
 914                  public String getResponseContent() {
 915
 916                                 return "Success";
 917                  }
 918
 919         };
 920
 921         new MockUp<JSONObject>(){
 922         @Mock
 923         public JSONObject fromObject(Object object){
 924                 JSONObject js = new JSONObject();
 925                 js.put("Result", "Success");
 926                 js.put("Check", "Ok");
 927                 js.put("downloadUri", "http://127.0.0.1:80");
 928                 return js;
 929         }
 930         };
 931
 932         new MockUp<DownloadCsarManager>(){
 933                 @Mock
 934                 public String download(String url, String filepath) {
 935                         return "Success";
 936
 937                 }
 938                 };
 939
 940                 new MockUp<DownloadCsarManager>(){
 941                 @Mock
 942                  public int unzipCSAR(String fileName, String filePath) {
 943                                 return 0;
 944
 945                 }
 946                 };
 947
 948         JSONObject vnfpkg = new JSONObject();
 949         vnfpkg.put("name", "test");
 950         JSONObject obj = new JSONObject();
 951         obj.put("csar_file_path", "src/test/resources/Check10.txt");
 952         obj.put("csar_file_name", "casrFile");
 953         vnfpkg.put("template", obj);
 954         Map<String, String> paramsMap = new HashMap<>();
 955         paramsMap.put("csarid", "csarid123");
 956         paramsMap.put("vnfmid", "vnfmid1234");
 957         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
 958         assertTrue(res.get("reason").equals("RestfulResponse is null."));
 959
 960     }
 961
 962     @Test(expected=JSONException.class)
 963     public void uploadVNFPackageTestSuccessUNZIPFTPSClient() {
 964
 965         new MockUp<VNFRestfulUtil>(){
 966                 @Mock
 967                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
 968                         RestfulResponse rr = new RestfulResponse();
 969                         Map<String, String> header = new HashMap<>();
 970                         header.put("Content-Type", "Application/Json");
 971                         header.put("X-FormId", "jhfdl");
 972                         rr.setRespHeaderMap(header);
 973                         rr.setStatus(200);
 974                         rr.setResponseJson("shdfhj");
 975
 976                         return rr;
 977
 978                 }
 979         };
 980
 981         new MockUp<RestfulResponse>(){
 982
 983                 @Mock
 984                  public String getResponseContent() {
 985
 986                                 return "Success";
 987                  }
 988
 989         };
 990
 991         new MockUp<JSONObject>(){
 992         @Mock
 993         public JSONObject fromObject(Object object){
 994                 JSONObject js = new JSONObject();
 995                 js.put("Result", "Success");
 996                 js.put("Check", "Ok");
 997                 js.put("downloadUri", "http://127.0.0.1:80");
 998                 return js;
 999         }
1000         };
1001
1002         new MockUp<DownloadCsarManager>(){
1003                 @Mock
1004                 public String download(String url, String filepath) {
1005                         return "Success";
1006
1007                 }
1008                 };
1009
1010                 new MockUp<DownloadCsarManager>(){
1011                 @Mock
1012                  public int unzipCSAR(String fileName, String filePath) {
1013                                 return 0;
1014
1015                 }
1016                 };
1017
1018         JSONObject vnfpkg = new JSONObject();
1019         vnfpkg.put("name", "test");
1020         JSONObject obj = new JSONObject();
1021         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1022         obj.put("csar_file_name", "casrFile");
1023         obj.put("ftp_server_ip", "https:127.0.0.1:80");
1024         obj.put("ftp_username", "FtpUser");
1025         obj.put("ftp_password", "FtpPass");
1026         vnfpkg.put("template", obj);
1027         Map<String, String> paramsMap = new HashMap<>();
1028         paramsMap.put("csarid", "csarid123");
1029         paramsMap.put("vnfmid", "vnfmid1234");
1030         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1031         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1032
1033     }
1034
1035     @Test(expected=JSONException.class)
1036     public void uploadVNFPackageTestSuccessUNZIPWithUrl() {
1037
1038         new MockUp<VNFRestfulUtil>(){
1039                 @Mock
1040                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1041                         RestfulResponse rr = new RestfulResponse();
1042                         Map<String, String> header = new HashMap<>();
1043                         header.put("Content-Type", "Application/Json");
1044                         header.put("X-FormId", "jhfdl");
1045                         rr.setRespHeaderMap(header);
1046                         rr.setStatus(200);
1047                         rr.setResponseJson("shdfhj");
1048
1049                         return rr;
1050
1051                 }
1052         };
1053
1054         new MockUp<RestfulResponse>(){
1055
1056                 @Mock
1057                  public String getResponseContent() {
1058
1059                                 return "Success";
1060                  }
1061
1062         };
1063
1064         new MockUp<DownloadCsarManager>(){
1065                 @Mock
1066                 public String download(String url, String filepath) {
1067                         return "Success";
1068
1069                 }
1070                 };
1071                 new MockUp<JSONObject>(){
1072                 @Mock
1073                 public JSONObject fromObject(Object object){
1074                         JSONObject js = new JSONObject();
1075                         js.put("Result", "Success");
1076                         js.put("Check", "Ok");
1077                         js.put("url", "http://localhost:80");
1078                         js.put("userName", "User");
1079                         js.put("password", "pass");
1080                         js.put("downloadUri", "http://127.0.0.1:80");
1081                         return js;
1082                 }
1083                 };
1084
1085                 new MockUp<DownloadCsarManager>(){
1086                 @Mock
1087                  public int unzipCSAR(String fileName, String filePath) {
1088                                 return 0;
1089
1090                 }
1091                 };
1092
1093         JSONObject vnfpkg = new JSONObject();
1094         vnfpkg.put("name", "test");
1095         JSONObject obj = new JSONObject();
1096         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1097         obj.put("csar_file_name", "casrFile");
1098         vnfpkg.put("template", obj);
1099         Map<String, String> paramsMap = new HashMap<>();
1100         paramsMap.put("csarid", "csarid123");
1101         paramsMap.put("vnfmid", "vnfmid1234");
1102         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1103         assertTrue(true);
1104
1105     }
1106
1107
1108     @Test
1109     public void uploadVNFPackageTestSuccessUNZIP1() {
1110
1111         new MockUp<RestfulResponse>(){
1112
1113                 @Mock
1114                  public String getResponseContent() {
1115
1116                                 return "Success";
1117                  }
1118
1119         };
1120
1121         new MockUp<DownloadCsarManager>(){
1122                 @Mock
1123                 public String download(String url, String filepath) {
1124                         return "Success";
1125
1126                 }
1127                 };
1128                 new MockUp<JSONObject>(){
1129                 @Mock
1130                 public JSONObject fromObject(Object object){
1131                         JSONObject js = new JSONObject();
1132                         js.put("Result", "Success");
1133                         js.put("Check", "Ok");
1134                         js.put("downloadUri", "http://127.0.0.1:80");
1135                         return js;
1136                 }
1137                 };
1138
1139                 new MockUp<DownloadCsarManager>(){
1140                 @Mock
1141                  public int unzipCSAR(String fileName, String filePath) {
1142                                 return 0;
1143
1144                 }
1145                 };
1146
1147         JSONObject vnfpkg = new JSONObject();
1148         vnfpkg.put("name", "test");
1149         JSONObject obj = new JSONObject();
1150         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1151         obj.put("csar_file_name", "casrFile");
1152         vnfpkg.put("template", obj);
1153         Map<String, String> paramsMap = new HashMap<>();
1154         paramsMap.put("csarid", "csarid123");
1155         paramsMap.put("vnfmid", "vnfmid1234");
1156         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1157         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1158
1159     }
1160
1161     @Test(expected=JSONException.class)
1162     public void uploadVNFPackageTestSuccessConnect() {
1163
1164         new MockUp<VNFRestfulUtil>(){
1165                 @Mock
1166                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1167                         RestfulResponse rr = new RestfulResponse();
1168                         Map<String, String> header = new HashMap<>();
1169                         header.put("Content-Type", "Application/Json");
1170                         header.put("X-FormId", "jhfdl");
1171                         rr.setRespHeaderMap(header);
1172                         rr.setStatus(200);
1173                         rr.setResponseJson("shdfhj");
1174
1175                         return rr;
1176
1177                 }
1178         };
1179
1180         new MockUp<RestfulResponse>(){
1181
1182                 @Mock
1183                  public String getResponseContent() {
1184
1185                                 return "Success";
1186                  }
1187
1188         };
1189
1190         new MockUp<DownloadCsarManager>(){
1191                 @Mock
1192                 public String download(String url, String filepath) {
1193                         return "Success";
1194
1195                 }
1196                 };
1197                 new MockUp<JSONObject>(){
1198                 @Mock
1199                 public JSONObject fromObject(Object object){
1200                         JSONObject js = new JSONObject();
1201                         js.put("Result", "Success");
1202                         js.put("Check", "Ok");
1203                         js.put("url", "http://localhost:80");
1204                         js.put("userName", "User");
1205                         js.put("password", "pass");
1206                         js.put("downloadUri", "http://127.0.0.1:80");
1207                         return js;
1208                 }
1209                 };
1210
1211                 new MockUp<DownloadCsarManager>(){
1212                 @Mock
1213                  public int unzipCSAR(String fileName, String filePath) {
1214                                 return 0;
1215
1216                 }
1217                 };
1218
1219                 new MockUp<ConnectMgrVnfm>(){
1220
1221                         @Mock
1222                          public int connect(JSONObject vnfmObj, String authModel) {
1223
1224                                 authModel = "accessSession";
1225                                 return 200;
1226                         }
1227
1228                 };
1229
1230         JSONObject vnfpkg = new JSONObject();
1231         vnfpkg.put("name", "test");
1232         JSONObject obj = new JSONObject();
1233         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1234         obj.put("csar_file_name", "casrFile");
1235         vnfpkg.put("template", obj);
1236         Map<String, String> paramsMap = new HashMap<>();
1237         paramsMap.put("csarid", "csarid123");
1238         paramsMap.put("vnfmid", "vnfmid1234");
1239         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1240         assertTrue(true);
1241
1242     }
1243
1244     @Test(expected=JSONException.class)
1245     public void uploadVNFPackageTestSuccessConnectPath() {
1246
1247         new MockUp<VNFRestfulUtil>(){
1248                 @Mock
1249                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1250                         RestfulResponse rr = new RestfulResponse();
1251                         Map<String, String> header = new HashMap<>();
1252                         header.put("Content-Type", "Application/Json");
1253                         header.put("X-FormId", "jhfdl");
1254                         rr.setRespHeaderMap(header);
1255                         rr.setStatus(200);
1256                         rr.setResponseJson("shdfhj");
1257
1258                         return rr;
1259
1260                 }
1261         };
1262
1263         new MockUp<RestfulResponse>(){
1264
1265                 @Mock
1266                  public String getResponseContent() {
1267
1268                                 return "Success";
1269                  }
1270
1271         };
1272
1273         new MockUp<DownloadCsarManager>(){
1274                 @Mock
1275                 public String download(String url, String filepath) {
1276                         return "Success";
1277
1278                 }
1279                 };
1280                 new MockUp<JSONObject>(){
1281                 @Mock
1282                 public JSONObject fromObject(Object object){
1283                         JSONObject js = new JSONObject();
1284                         js.put("Result", "Success");
1285                         js.put("Check", "Ok");
1286                         js.put("url", "http://localhost:80");
1287                         js.put("userName", "User");
1288                         js.put("password", "pass");
1289                         js.put("downloadUri", "http://127.0.0.1:80");
1290                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
1291                         js.put("keyStorePass", "Changeme_123");
1292                         js.put("keyStoreType", "PKCS12");
1293                         JSONArray ja = new JSONArray();
1294                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1295                         ja.add(str);
1296                         js.put("vim_info", ja);
1297                         return js;
1298                 }
1299                 };
1300
1301                 new MockUp<DownloadCsarManager>(){
1302                 @Mock
1303                  public int unzipCSAR(String fileName, String filePath) {
1304                                 return 0;
1305
1306                 }
1307                 };
1308
1309                 new MockUp<ConnectMgrVnfm>(){
1310
1311                         @Mock
1312                          public int connect(JSONObject vnfmObj, String authModel) {
1313                                 vnfmObj.put("connToken", "accessSession");
1314                                 vnfmObj.put("Content-Type", "Application/Json");
1315                                 authModel = "accessSession";
1316                                 return 200;
1317                         }
1318
1319                 };
1320
1321                 new MockUp<HttpClient>(){
1322                         @Mock
1323                         public int executeMethod(HttpMethod method) {
1324                             return 200;
1325                         }
1326                     };
1327
1328                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1329
1330                  new MockUp<HttpMethodBase>(){
1331
1332                         @Mock
1333                          public int getStatusCode(){
1334
1335                                 return 200;
1336                         }
1337
1338                         @Mock
1339                          public String getResponseBodyAsString()
1340                                            throws IOException
1341                                           {
1342                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1343                                 JSONObject jobj = new JSONObject();
1344                                 jobj.put("Status", 200);
1345                                 jobj.put("UserName", "User");
1346                                 jobj.put("password", "pass");
1347                                 JSONArray ja = new JSONArray();
1348                                 ja.add(str);
1349                                 jobj.put("vim_info", ja);
1350                                 String str1 = jobj.toString();
1351                                 return str1;
1352                                            }
1353                     };
1354
1355         JSONObject vnfpkg = new JSONObject();
1356         vnfpkg.put("name", "test");
1357         JSONObject obj = new JSONObject();
1358         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1359         obj.put("csar_file_name", "casrFile");
1360         vnfpkg.put("template", obj);
1361         Map<String, String> paramsMap = new HashMap<>();
1362         paramsMap.put("csarid", "csarid123");
1363         paramsMap.put("vnfmid", "vnfmid1234");
1364         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1365         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1366
1367     }
1368
1369     @Test(expected=JSONException.class)
1370     public void uploadVNFPackageTestSuccessConnectPath500() {
1371
1372         new MockUp<VNFRestfulUtil>(){
1373                 @Mock
1374                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1375                         RestfulResponse rr = new RestfulResponse();
1376                         Map<String, String> header = new HashMap<>();
1377                         header.put("Content-Type", "Application/Json");
1378                         header.put("X-FormId", "jhfdl");
1379                         rr.setRespHeaderMap(header);
1380                         rr.setStatus(200);
1381                         rr.setResponseJson("shdfhj");
1382
1383                         return rr;
1384
1385                 }
1386         };
1387
1388         new MockUp<RestfulResponse>(){
1389
1390                 @Mock
1391                  public String getResponseContent() {
1392
1393                                 return "Success";
1394                  }
1395
1396         };
1397
1398         new MockUp<DownloadCsarManager>(){
1399                 @Mock
1400                 public String download(String url, String filepath) {
1401                         return "Success";
1402
1403                 }
1404                 };
1405                 new MockUp<JSONObject>(){
1406                 @Mock
1407                 public JSONObject fromObject(Object object){
1408                         JSONObject js = new JSONObject();
1409                         js.put("Result", "Success");
1410                         js.put("Check", "Ok");
1411                         js.put("url", "http://localhost:80");
1412                         js.put("userName", "User");
1413                         js.put("password", "pass");
1414                         js.put("downloadUri", "http://127.0.0.1:80");
1415                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
1416                         js.put("keyStorePass", "Changeme_123");
1417                         js.put("keyStoreType", "PKCS12");
1418                         JSONArray ja = new JSONArray();
1419                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1420                         ja.add(str);
1421                         js.put("vim_info", ja);
1422                         return js;
1423                 }
1424                 };
1425
1426                 new MockUp<DownloadCsarManager>(){
1427                 @Mock
1428                  public int unzipCSAR(String fileName, String filePath) {
1429                                 return 0;
1430
1431                 }
1432                 };
1433
1434                 new MockUp<ConnectMgrVnfm>(){
1435
1436                         @Mock
1437                          public int connect(JSONObject vnfmObj, String authModel) {
1438                                 vnfmObj.put("connToken", "accessSession");
1439                                 vnfmObj.put("Content-Type", "Application/Json");
1440                                 authModel = "accessSession";
1441                                 return 200;
1442                         }
1443
1444                 };
1445
1446                 new MockUp<HttpClient>(){
1447                         @Mock
1448                         public int executeMethod(HttpMethod method) {
1449                             return 200;
1450                         }
1451                     };
1452
1453                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1454
1455                  new MockUp<HttpMethodBase>(){
1456
1457                         @Mock
1458                          public int getStatusCode(){
1459
1460                                 return 500;
1461                         }
1462
1463                         @Mock
1464                          public String getResponseBodyAsString()
1465                                            throws IOException
1466                                           {
1467                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1468                                 JSONObject jobj = new JSONObject();
1469                                 jobj.put("Status", 500);
1470                                 jobj.put("UserName", "User");
1471                                 jobj.put("password", "pass");
1472                                 JSONArray ja = new JSONArray();
1473                                 ja.add(str);
1474                                 jobj.put("vim_info", ja);
1475                                 String str1 = jobj.toString();
1476                                 return str1;
1477                                            }
1478                     };
1479
1480         JSONObject vnfpkg = new JSONObject();
1481         vnfpkg.put("name", "test");
1482         JSONObject obj = new JSONObject();
1483         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1484         obj.put("csar_file_name", "casrFile");
1485         vnfpkg.put("template", obj);
1486         Map<String, String> paramsMap = new HashMap<>();
1487         paramsMap.put("csarid", "csarid123");
1488         paramsMap.put("vnfmid", "vnfmid1234");
1489         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1490         assertTrue(true);
1491
1492     }
1493
1494     @Test(expected=JSONException.class)
1495     public void uploadVNFPackageTestSuccessConnectPathEmpty() {
1496
1497         new MockUp<VNFRestfulUtil>(){
1498                 @Mock
1499                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1500                         RestfulResponse rr = new RestfulResponse();
1501                         Map<String, String> header = new HashMap<>();
1502                         header.put("Content-Type", "Application/Json");
1503                         header.put("X-FormId", "jhfdl");
1504                         rr.setRespHeaderMap(header);
1505                         rr.setStatus(200);
1506                         rr.setResponseJson("shdfhj");
1507
1508                         return rr;
1509
1510                 }
1511         };
1512
1513         new MockUp<RestfulResponse>(){
1514
1515                 @Mock
1516                  public String getResponseContent() {
1517
1518                                 return "Success";
1519                  }
1520
1521         };
1522
1523         new MockUp<DownloadCsarManager>(){
1524                 @Mock
1525                 public String download(String url, String filepath) {
1526                         return "Success";
1527
1528                 }
1529                 };
1530                 new MockUp<JSONObject>(){
1531                 @Mock
1532                 public JSONObject fromObject(Object object){
1533                         JSONObject js = new JSONObject();
1534                         js.put("Result", "Success");
1535                         js.put("Check", "Ok");
1536                         js.put("url", "http://localhost:80");
1537                         js.put("userName", "User");
1538                         js.put("password", "pass");
1539                         js.put("downloadUri", "http://127.0.0.1:80");
1540                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
1541                         js.put("keyStorePass", "Changeme_123");
1542                         js.put("keyStoreType", "PKCS12");
1543                         JSONArray ja = new JSONArray();
1544                         String str = "{\n\"vim_id\": \"\",\n\t\t\"vim-info\": \"1\",\n\t\t\"vim-name\": \"\"\n}";
1545                         ja.add(str);
1546                         js.put("vim_info", ja);
1547                         return js;
1548                 }
1549                 };
1550
1551                 new MockUp<DownloadCsarManager>(){
1552                 @Mock
1553                  public int unzipCSAR(String fileName, String filePath) {
1554                                 return 0;
1555
1556                 }
1557                 };
1558
1559                 new MockUp<ConnectMgrVnfm>(){
1560
1561                         @Mock
1562                          public int connect(JSONObject vnfmObj, String authModel) {
1563                                 vnfmObj.put("connToken", "accessSession");
1564                                 vnfmObj.put("Content-Type", "Application/Json");
1565                                 authModel = "accessSession";
1566                                 return 200;
1567                         }
1568
1569                 };
1570
1571                 new MockUp<HttpClient>(){
1572                         @Mock
1573                         public int executeMethod(HttpMethod method) {
1574                             return 200;
1575                         }
1576                     };
1577
1578                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1579
1580                  new MockUp<HttpMethodBase>(){
1581
1582                         @Mock
1583                          public int getStatusCode(){
1584
1585                                 return 200;
1586                         }
1587
1588                         @Mock
1589                          public String getResponseBodyAsString()
1590                                            throws IOException
1591                                           {
1592                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1593                                 JSONObject jobj = new JSONObject();
1594                                 jobj.put("Status", 200);
1595                                 jobj.put("UserName", "User");
1596                                 jobj.put("password", "pass");
1597                                 JSONArray ja = new JSONArray();
1598                                 ja.add(str);
1599                                 jobj.put("vim_info", ja);
1600                                 String str1 = jobj.toString();
1601                                 return str1;
1602                                            }
1603                     };
1604
1605         JSONObject vnfpkg = new JSONObject();
1606         vnfpkg.put("name", "test");
1607         JSONObject obj = new JSONObject();
1608         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1609         obj.put("csar_file_name", "casrFile");
1610         vnfpkg.put("template", obj);
1611         Map<String, String> paramsMap = new HashMap<>();
1612         paramsMap.put("csarid", "csarid123");
1613         paramsMap.put("vnfmid", "vnfmid1234");
1614         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1615         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1616
1617     }
1618     @Test(expected=JSONException.class)
1619     public void uploadVNFPackageTestSuccessId() {
1620
1621         new MockUp<VNFRestfulUtil>(){
1622                 @Mock
1623                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1624                         RestfulResponse rr = new RestfulResponse();
1625                         Map<String, String> header = new HashMap<>();
1626                         header.put("Content-Type", "Application/Json");
1627                         header.put("X-FormId", "jhfdl");
1628                         rr.setRespHeaderMap(header);
1629                         rr.setStatus(200);
1630                         rr.setResponseJson("shdfhj");
1631
1632                         return rr;
1633
1634                 }
1635         };
1636
1637         new MockUp<RestfulResponse>(){
1638
1639                 @Mock
1640                  public String getResponseContent() {
1641
1642                                 return "Success";
1643                  }
1644
1645         };
1646
1647         new MockUp<DownloadCsarManager>(){
1648                 @Mock
1649                 public String download(String url, String filepath) {
1650                         return "Success";
1651
1652                 }
1653                 };
1654                 new MockUp<JSONObject>(){
1655                 @Mock
1656                 public JSONObject fromObject(Object object){
1657                         JSONObject js = new JSONObject();
1658                         js.put("id", "upload-id-123");
1659                         js.put("Result", "Success");
1660                         js.put("Check", "Ok");
1661                         js.put("url", "http://localhost:80");
1662                         js.put("userName", "User");
1663                         js.put("password", "pass");
1664                         js.put("downloadUri", "http://127.0.0.1:80");
1665                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
1666                         js.put("keyStorePass", "Changeme_123");
1667                         js.put("keyStoreType", "PKCS12");
1668                         JSONArray ja = new JSONArray();
1669                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1670                         ja.add(str);
1671                         js.put("vim_info", ja);
1672                         return js;
1673                 }
1674                 };
1675
1676                 new MockUp<DownloadCsarManager>(){
1677                 @Mock
1678                  public int unzipCSAR(String fileName, String filePath) {
1679                                 return 0;
1680
1681                 }
1682                 };
1683
1684                 new MockUp<ConnectMgrVnfm>(){
1685
1686                         @Mock
1687                          public int connect(JSONObject vnfmObj, String authModel) {
1688                                 vnfmObj.put("connToken", "accessSession");
1689                                 vnfmObj.put("Content-Type", "Application/Json");
1690                                 authModel = "accessSession";
1691                                 return 200;
1692                         }
1693
1694                 };
1695
1696                 new MockUp<HttpClient>(){
1697                         @Mock
1698                         public int executeMethod(HttpMethod method) {
1699                             return 200;
1700                         }
1701                     };
1702
1703                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1704
1705                  new MockUp<HttpMethodBase>(){
1706
1707                         @Mock
1708                          public int getStatusCode(){
1709
1710                                 return 200;
1711                         }
1712
1713                         @Mock
1714                          public String getResponseBodyAsString()
1715                                            throws IOException
1716                                           {
1717                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1718                                 JSONObject jobj = new JSONObject();
1719                                 jobj.put("Status", 200);
1720                                 jobj.put("UserName", "User");
1721                                 jobj.put("password", "pass");
1722                                 JSONArray ja = new JSONArray();
1723                                 ja.add(str);
1724                                 jobj.put("vim_info", ja);
1725                                 String str1 = jobj.toString();
1726                                 return str1;
1727                                            }
1728                     };
1729
1730         JSONObject vnfpkg = new JSONObject();
1731         vnfpkg.put("name", "test");
1732         JSONObject obj = new JSONObject();
1733         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1734         obj.put("csar_file_name", "casrFile");
1735         vnfpkg.put("template", obj);
1736         Map<String, String> paramsMap = new HashMap<>();
1737         paramsMap.put("csarid", "csarid123");
1738         paramsMap.put("vnfmid", "vnfmid1234");
1739         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1740         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1741
1742     }
1743     @Test(expected=JSONException.class)
1744     public void uploadVNFPackageTestSuccessIdNull() {
1745
1746         new MockUp<VNFRestfulUtil>(){
1747                 @Mock
1748                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1749                         RestfulResponse rr = new RestfulResponse();
1750                         Map<String, String> header = new HashMap<>();
1751                         header.put("Content-Type", "Application/Json");
1752                         header.put("X-FormId", "jhfdl");
1753                         rr.setRespHeaderMap(header);
1754                         rr.setStatus(200);
1755                         rr.setResponseJson("shdfhj");
1756
1757                         return rr;
1758
1759                 }
1760         };
1761
1762         new MockUp<RestfulResponse>(){
1763
1764                 @Mock
1765                  public String getResponseContent() {
1766
1767                                 return "Success";
1768                  }
1769
1770         };
1771
1772         new MockUp<DownloadCsarManager>(){
1773                 @Mock
1774                 public String download(String url, String filepath) {
1775                         return "Success";
1776
1777                 }
1778                 };
1779                 new MockUp<JSONObject>(){
1780                 @Mock
1781                 public JSONObject fromObject(Object object){
1782                         JSONObject js = new JSONObject();
1783                         js.put("id", null);
1784                         js.put("Result", "Success");
1785                         js.put("Check", "Ok");
1786                         js.put("url", "http://localhost:80");
1787                         js.put("userName", "User");
1788                         js.put("password", "pass");
1789                         js.put("downloadUri", "http://127.0.0.1:80");
1790                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
1791                         js.put("keyStorePass", "Changeme_123");
1792                         js.put("keyStoreType", "PKCS12");
1793                         JSONArray ja = new JSONArray();
1794                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1795                         ja.add(str);
1796                         js.put("vim_info", ja);
1797                         return js;
1798                 }
1799                 };
1800
1801                 new MockUp<DownloadCsarManager>(){
1802                 @Mock
1803                  public int unzipCSAR(String fileName, String filePath) {
1804                                 return 0;
1805
1806                 }
1807                 };
1808
1809                 new MockUp<ConnectMgrVnfm>(){
1810
1811                         @Mock
1812                          public int connect(JSONObject vnfmObj, String authModel) {
1813                                 vnfmObj.put("connToken", "accessSession");
1814                                 vnfmObj.put("Content-Type", "Application/Json");
1815                                 authModel = "accessSession";
1816                                 return 200;
1817                         }
1818
1819                 };
1820
1821                 new MockUp<HttpClient>(){
1822                         @Mock
1823                         public int executeMethod(HttpMethod method) {
1824                             return 200;
1825                         }
1826                     };
1827
1828                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1829
1830                  new MockUp<HttpMethodBase>(){
1831
1832                         @Mock
1833                          public int getStatusCode(){
1834
1835                                 return 200;
1836                         }
1837
1838                         @Mock
1839                          public String getResponseBodyAsString()
1840                                            throws IOException
1841                                           {
1842                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1843                                 JSONObject jobj = new JSONObject();
1844                                 jobj.put("Status", 200);
1845                                 jobj.put("UserName", "User");
1846                                 jobj.put("password", "pass");
1847                                 JSONArray ja = new JSONArray();
1848                                 ja.add(str);
1849                                 jobj.put("vim_info", ja);
1850                                 String str1 = jobj.toString();
1851                                 return str1;
1852                                            }
1853                     };
1854
1855         JSONObject vnfpkg = new JSONObject();
1856         vnfpkg.put("name", "test");
1857         JSONObject obj = new JSONObject();
1858         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1859         obj.put("csar_file_name", "casrFile");
1860         vnfpkg.put("template", obj);
1861         Map<String, String> paramsMap = new HashMap<>();
1862         paramsMap.put("csarid", "csarid123");
1863         paramsMap.put("vnfmid", "vnfmid1234");
1864         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1865         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1866
1867     }
1868     @Test(expected=JSONException.class)
1869     public void uploadVNFPackageTestSuccessIdFile0() {
1870
1871         new MockUp<VNFRestfulUtil>(){
1872                 @Mock
1873                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
1874                         RestfulResponse rr = new RestfulResponse();
1875                         Map<String, String> header = new HashMap<>();
1876                         header.put("Content-Type", "Application/Json");
1877                         header.put("X-FormId", "jhfdl");
1878                         rr.setRespHeaderMap(header);
1879                         rr.setStatus(200);
1880                         rr.setResponseJson("shdfhj");
1881
1882                         return rr;
1883
1884                 }
1885         };
1886
1887         new MockUp<RestfulResponse>(){
1888
1889                 @Mock
1890                  public String getResponseContent() {
1891
1892                                 return "Success";
1893                  }
1894
1895         };
1896
1897         new MockUp<DownloadCsarManager>(){
1898                 @Mock
1899                 public String download(String url, String filepath) {
1900                         return "Success";
1901
1902                 }
1903                 };
1904                 new MockUp<JSONObject>(){
1905                 @Mock
1906                 public JSONObject fromObject(Object object){
1907                         JSONObject js = new JSONObject();
1908                         js.put("id", "");
1909                         js.put("Result", "Success");
1910                         js.put("Check", "Ok");
1911                         js.put("url", "http://localhost:80");
1912                         js.put("userName", "User");
1913                         js.put("password", "pass");
1914                         js.put("downloadUri", "http://127.0.0.1:80");
1915                         js.put("keyStore", "C:/Users/Huawei/Desktop/Check10.txt");
1916                         js.put("keyStorePass", "Changeme_123");
1917                         js.put("keyStoreType", "PKCS12");
1918                         JSONArray ja = new JSONArray();
1919                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1920                         ja.add(str);
1921                         js.put("vim_info", ja);
1922                         return js;
1923                 }
1924                 };
1925
1926                 new MockUp<DownloadCsarManager>(){
1927                 @Mock
1928                  public int unzipCSAR(String fileName, String filePath) {
1929                                 return 0;
1930
1931                 }
1932                 };
1933
1934                 new MockUp<ConnectMgrVnfm>(){
1935
1936                         @Mock
1937                          public int connect(JSONObject vnfmObj, String authModel) {
1938                                 vnfmObj.put("connToken", "accessSession");
1939                                 vnfmObj.put("Content-Type", "Application/Json");
1940                                 authModel = "accessSession";
1941                                 return 200;
1942                         }
1943
1944                 };
1945
1946                 new MockUp<HttpClient>(){
1947                         @Mock
1948                         public int executeMethod(HttpMethod method) {
1949                             return 200;
1950                         }
1951                     };
1952
1953                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
1954
1955                  new MockUp<HttpMethodBase>(){
1956
1957                         @Mock
1958                          public int getStatusCode(){
1959
1960                                 return 200;
1961                         }
1962
1963                         @Mock
1964                          public String getResponseBodyAsString()
1965                                            throws IOException
1966                                           {
1967                                 String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
1968                                 JSONObject jobj = new JSONObject();
1969                                 jobj.put("Status", 200);
1970                                 jobj.put("UserName", "User");
1971                                 jobj.put("password", "pass");
1972                                 JSONArray ja = new JSONArray();
1973                                 ja.add(str);
1974                                 jobj.put("vim_info", ja);
1975                                 String str1 = jobj.toString();
1976                                 return str1;
1977                                            }
1978                     };
1979
1980         JSONObject vnfpkg = new JSONObject();
1981         vnfpkg.put("name", "test");
1982         JSONObject obj = new JSONObject();
1983         obj.put("csar_file_path", "src/test/resources/Check10.txt");
1984         obj.put("csar_file_name", "casrFile");
1985         vnfpkg.put("template", obj);
1986         Map<String, String> paramsMap = new HashMap<>();
1987         paramsMap.put("csarid", "csarid123");
1988         paramsMap.put("vnfmid", "vnfmid1234");
1989         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
1990         assertTrue(res.get("reason").equals("RestfulResponse is null."));
1991
1992     }
1993
1994     @Test(expected=JSONException.class)
1995     public void uploadVNFPackageTestSuccessId500() {
1996
1997         new MockUp<VNFRestfulUtil>(){
1998                 @Mock
1999                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2000                         RestfulResponse rr = new RestfulResponse();
2001                         Map<String, String> header = new HashMap<>();
2002                         header.put("Content-Type", "Application/Json");
2003                         header.put("X-FormId", "jhfdl");
2004                         rr.setRespHeaderMap(header);
2005                         rr.setStatus(200);
2006                         rr.setResponseJson("shdfhj");
2007
2008                         return rr;
2009
2010                 }
2011         };
2012
2013         new MockUp<RestfulResponse>(){
2014
2015                 @Mock
2016                  public String getResponseContent() {
2017
2018                                 return "Success";
2019                  }
2020
2021         };
2022
2023         new MockUp<DownloadCsarManager>(){
2024                 @Mock
2025                 public String download(String url, String filepath) {
2026                         return "Success";
2027
2028                 }
2029                 };
2030                 new MockUp<JSONObject>(){
2031                 @Mock
2032                 public JSONObject fromObject(Object object){
2033                         JSONObject js = new JSONObject();
2034                         js.put("id", "upload-id-123");
2035                         js.put("Result", "Success");
2036                         js.put("Check", "Ok");
2037                         js.put("url", "http://localhost:80");
2038                         js.put("userName", "User");
2039                         js.put("password", "pass");
2040                         js.put("downloadUri", "http://127.0.0.1:80");
2041                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2042                         js.put("keyStorePass", "Changeme_123");
2043                         js.put("keyStoreType", "PKCS12");
2044                         JSONArray ja = new JSONArray();
2045                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2046                         ja.add(str);
2047                         js.put("vim_info", ja);
2048                         return js;
2049                 }
2050                 };
2051
2052                 new MockUp<DownloadCsarManager>(){
2053                 @Mock
2054                  public int unzipCSAR(String fileName, String filePath) {
2055                                 return 0;
2056
2057                 }
2058                 };
2059
2060                 new MockUp<ConnectMgrVnfm>(){
2061
2062                         @Mock
2063                          public int connect(JSONObject vnfmObj, String authModel) {
2064                                 vnfmObj.put("connToken", "accessSession");
2065                                 vnfmObj.put("Content-Type", "Application/Json");
2066                                 authModel = "accessSession";
2067                                 return 200;
2068                         }
2069
2070                 };
2071
2072                 new MockUp<HttpClient>(){
2073                         @Mock
2074                         public int executeMethod(HttpMethod method) {
2075                             return 200;
2076                         }
2077                     };
2078
2079                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2080
2081         JSONObject vnfpkg = new JSONObject();
2082         vnfpkg.put("name", "test");
2083         JSONObject obj = new JSONObject();
2084         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2085         obj.put("csar_file_name", "casrFile");
2086         vnfpkg.put("template", obj);
2087         Map<String, String> paramsMap = new HashMap<>();
2088         paramsMap.put("csarid", "csarid123");
2089         paramsMap.put("vnfmid", "vnfmid1234");
2090         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2091         assertTrue(true);
2092
2093     }
2094
2095     @Test(expected=JSONException.class)
2096     public void uploadVNFPackageTestSuccessIdEmpty() {
2097
2098         new MockUp<VNFRestfulUtil>(){
2099                 @Mock
2100                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2101                         RestfulResponse rr = new RestfulResponse();
2102                         Map<String, String> header = new HashMap<>();
2103                         header.put("Content-Type", "Application/Json");
2104                         header.put("X-FormId", "jhfdl");
2105                         rr.setRespHeaderMap(header);
2106                         rr.setStatus(200);
2107                         rr.setResponseJson("shdfhj");
2108
2109                         return rr;
2110
2111                 }
2112         };
2113
2114         new MockUp<RestfulResponse>(){
2115
2116                 @Mock
2117                  public String getResponseContent() {
2118
2119                                 return "Success";
2120                  }
2121
2122         };
2123
2124         new MockUp<DownloadCsarManager>(){
2125                 @Mock
2126                 public String download(String url, String filepath) {
2127                         return "Success";
2128
2129                 }
2130                 };
2131                 new MockUp<JSONObject>(){
2132                 @Mock
2133                 public JSONObject fromObject(Object object){
2134                         JSONObject js = new JSONObject();
2135                         js.put("id", "");
2136                         js.put("Result", "Success");
2137                         js.put("Check", "Ok");
2138                         js.put("url", "http://localhost:80");
2139                         js.put("userName", "User");
2140                         js.put("password", "pass");
2141                         js.put("downloadUri", "http://127.0.0.1:80");
2142                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2143                         js.put("keyStorePass", "Changeme_123");
2144                         js.put("keyStoreType", "PKCS12");
2145                         JSONArray ja = new JSONArray();
2146                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2147                         ja.add(str);
2148                         js.put("vim_info", ja);
2149                         return js;
2150                 }
2151                 };
2152
2153                 new MockUp<DownloadCsarManager>(){
2154                 @Mock
2155                  public int unzipCSAR(String fileName, String filePath) {
2156                                 return 0;
2157
2158                 }
2159                 };
2160
2161                 new MockUp<ConnectMgrVnfm>(){
2162
2163                         @Mock
2164                          public int connect(JSONObject vnfmObj, String authModel) {
2165                                 vnfmObj.put("connToken", "accessSession");
2166                                 vnfmObj.put("Content-Type", "Application/Json");
2167                                 authModel = "accessSession";
2168                                 return 200;
2169                         }
2170
2171                 };
2172
2173                 new MockUp<HttpClient>(){
2174                         @Mock
2175                         public int executeMethod(HttpMethod method) {
2176                             return 200;
2177                         }
2178                     };
2179
2180                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2181
2182         JSONObject vnfpkg = new JSONObject();
2183         vnfpkg.put("name", "test");
2184         JSONObject obj = new JSONObject();
2185         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2186         obj.put("csar_file_name", "casrFile");
2187         vnfpkg.put("template", obj);
2188         Map<String, String> paramsMap = new HashMap<>();
2189         paramsMap.put("csarid", "csarid123");
2190         paramsMap.put("vnfmid", "vnfmid1234");
2191         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2192         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2193
2194     }
2195
2196     @Test(expected=JSONException.class)
2197     public void uploadVNFPackageTestSuccessTemplete() {
2198
2199         new MockUp<VNFRestfulUtil>(){
2200                 @Mock
2201                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2202                         RestfulResponse rr = new RestfulResponse();
2203                         Map<String, String> header = new HashMap<>();
2204                         header.put("Content-Type", "Application/Json");
2205                         header.put("X-FormId", "jhfdl");
2206                         rr.setRespHeaderMap(header);
2207                         rr.setStatus(200);
2208                         rr.setResponseJson("shdfhj");
2209
2210                         return rr;
2211
2212                 }
2213         };
2214
2215         new MockUp<RestfulResponse>(){
2216
2217                 @Mock
2218                  public String getResponseContent() {
2219
2220                                 return "Success";
2221                  }
2222
2223         };
2224
2225         new MockUp<DownloadCsarManager>(){
2226                 @Mock
2227                 public String download(String url, String filepath) {
2228                         return "Success";
2229
2230                 }
2231                 };
2232                 new MockUp<JSONObject>(){
2233                 @Mock
2234                 public JSONObject fromObject(Object object){
2235                         JSONObject js = new JSONObject();
2236                         js.put("id", "upload-id-123");
2237                         js.put("Result", "Success");
2238                         js.put("Check", "Ok");
2239                         js.put("url", "http://localhost:80");
2240                         js.put("userName", "User");
2241                         js.put("password", "pass");
2242                         js.put("downloadUri", "http://127.0.0.1:80");
2243                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2244                         js.put("keyStorePass", "Changeme_123");
2245                         js.put("keyStoreType", "PKCS12");
2246                         JSONArray ja = new JSONArray();
2247                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2248                         ja.add(str);
2249                         JSONArray ja1 = new JSONArray();
2250                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2251                         ja1.add(str1);
2252                         js.put("vim_info", ja);
2253                         js.put("templates", ja1);
2254                         return js;
2255                 }
2256                 };
2257
2258                 new MockUp<DownloadCsarManager>(){
2259                 @Mock
2260                  public int unzipCSAR(String fileName, String filePath) {
2261                                 return 0;
2262
2263                 }
2264                 };
2265
2266                 new MockUp<ConnectMgrVnfm>(){
2267
2268                         @Mock
2269                          public int connect(JSONObject vnfmObj, String authModel) {
2270                                 vnfmObj.put("connToken", "accessSession");
2271                                 vnfmObj.put("Content-Type", "Application/Json");
2272                                 authModel = "accessSession";
2273                                 return 200;
2274                         }
2275
2276                 };
2277
2278                 new MockUp<HttpClient>(){
2279                         @Mock
2280                         public int executeMethod(HttpMethod method) {
2281                             return 200;
2282                         }
2283                     };
2284
2285                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2286
2287         JSONObject vnfpkg = new JSONObject();
2288         vnfpkg.put("name", "test");
2289         JSONObject obj = new JSONObject();
2290         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2291         obj.put("csar_file_name", "casrFile");
2292         vnfpkg.put("template", obj);
2293         Map<String, String> paramsMap = new HashMap<>();
2294         paramsMap.put("csarid", "csarid123");
2295         paramsMap.put("vnfmid", "vnfmid1234");
2296         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2297         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2298
2299     }
2300
2301     @Test(expected=JSONException.class)
2302     public void uploadVNFPackageTestSuccessTempleteForVPlan() {
2303
2304         new MockUp<VNFRestfulUtil>(){
2305                 @Mock
2306                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2307                         RestfulResponse rr = new RestfulResponse();
2308                         Map<String, String> header = new HashMap<>();
2309                         header.put("Content-Type", "Application/Json");
2310                         header.put("X-FormId", "jhfdl");
2311                         rr.setRespHeaderMap(header);
2312                         rr.setStatus(200);
2313                         rr.setResponseJson("shdfhj");
2314
2315                         return rr;
2316
2317                 }
2318         };
2319
2320         new MockUp<RestfulResponse>(){
2321
2322                 @Mock
2323                  public String getResponseContent() {
2324
2325                                 return "Success";
2326                  }
2327
2328         };
2329
2330         new MockUp<DownloadCsarManager>(){
2331                 @Mock
2332                 public String download(String url, String filepath) {
2333                         return "Success";
2334
2335                 }
2336                 };
2337                 new MockUp<JSONObject>(){
2338                 @Mock
2339                 public JSONObject fromObject(Object object){
2340                         JSONObject js = new JSONObject();
2341                         js.put("id", "upload-id-123");
2342                         js.put("Result", "Success");
2343                         js.put("Check", "Ok");
2344                         js.put("url", "http://localhost:80");
2345                         js.put("userName", "User");
2346                         js.put("password", "pass");
2347                         js.put("downloadUri", "http://127.0.0.1:80");
2348                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2349                         js.put("keyStorePass", "Changeme_123");
2350                         js.put("keyStoreType", "PKCS12");
2351                         JSONArray ja = new JSONArray();
2352                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2353                         ja.add(str);
2354                         JSONArray ja1 = new JSONArray();
2355                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2356                         ja1.add(str1);
2357                         JSONArray ja2 = new JSONArray();
2358                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2359                         ja2.add(str2);
2360                         JSONObject jsObject = new JSONObject();
2361                         jsObject.put("downloadUrl", "http://localhost:80");
2362                         jsObject.put("csarName", "Csar_Check");
2363                         js.put("vim_info", ja);
2364                         js.put("template", ja2);
2365                         js.put("templates", ja1);
2366                         js.put("packageInfo", jsObject);
2367                         return js;
2368                 }
2369                 };
2370
2371                 new MockUp<DownloadCsarManager>(){
2372                 @Mock
2373                  public int unzipCSAR(String fileName, String filePath) {
2374                                 return 0;
2375
2376                 }
2377                 };
2378
2379                 new MockUp<ConnectMgrVnfm>(){
2380
2381                         @Mock
2382                          public int connect(JSONObject vnfmObj, String authModel) {
2383                                 vnfmObj.put("connToken", "accessSession");
2384                                 vnfmObj.put("Content-Type", "Application/Json");
2385                                 authModel = "accessSession";
2386                                 return 200;
2387                         }
2388
2389                 };
2390
2391                 new MockUp<HttpClient>(){
2392                         @Mock
2393                         public int executeMethod(HttpMethod method) {
2394                             return 200;
2395                         }
2396                     };
2397
2398                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2399
2400         JSONObject vnfpkg = new JSONObject();
2401         vnfpkg.put("name", "test");
2402         JSONObject obj = new JSONObject();
2403         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2404         obj.put("csar_file_name", "casrFile");
2405         vnfpkg.put("template", obj);
2406         Map<String, String> paramsMap = new HashMap<>();
2407         paramsMap.put("csarid", "csarid123");
2408         paramsMap.put("vnfmid", "vnfmid1234");
2409         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2410         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2411
2412     }
2413
2414
2415
2416     @Test
2417     public void uploadVNFPackageTestParamMapEmpty() {
2418
2419         JSONObject vnfpkg = new JSONObject();
2420         vnfpkg.put("name", "test");
2421         JSONObject obj = new JSONObject();
2422         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2423         obj.put("csar_file_name", "casrFile");
2424         vnfpkg.put("template", obj);
2425         Map<String, String> paramsMap = new HashMap<>();
2426         paramsMap.put("", "");
2427         paramsMap.put("", "");
2428         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2429         assertTrue(true);
2430
2431     }
2432
2433     @Test
2434     public void uploadVNFPackageTestVnfpkgEmpty() {
2435
2436          JSONObject vnfpkg = new JSONObject();
2437          vnfpkg.put("", "");
2438          JSONObject obj = new JSONObject();
2439          obj.put("csar_file_path", "src/test/resources/Check10.txt");
2440          obj.put("csar_file_name", "casrFile");
2441          vnfpkg.put("template", obj);
2442          Map<String, String> paramsMap = new HashMap<>();
2443          paramsMap.put("csarid", "csarid123");
2444          paramsMap.put("vnfmid", "vnfmid1234");
2445          JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2446          assertTrue(true);
2447
2448     }
2449
2450         @Test
2451     public void readScaleInVmIdFromJsonTest() {
2452
2453         System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2454         AdapterResourceManager.readScaleInVmIdFromJson();
2455     }
2456
2457         @Test
2458     public void readScaleInVmIdFromJsonTestNoFile() {
2459
2460                 System.setProperty("catalina.base", "src/test/resources");
2461         AdapterResourceManager.readScaleInVmIdFromJson();
2462     }
2463
2464     @Test(expected=JSONException.class)
2465     public void uploadVNFPackageTestWithCscf() {
2466
2467         new MockUp<VNFRestfulUtil>(){
2468                 @Mock
2469                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2470                         RestfulResponse rr = new RestfulResponse();
2471                         Map<String, String> header = new HashMap<>();
2472                         header.put("Content-Type", "Application/Json");
2473                         header.put("X-FormId", "jhfdl");
2474                         rr.setRespHeaderMap(header);
2475                         rr.setStatus(200);
2476                         rr.setResponseJson("shdfhj");
2477
2478                         return rr;
2479
2480                 }
2481         };
2482
2483         new MockUp<RestfulResponse>(){
2484
2485                 @Mock
2486                  public String getResponseContent() {
2487
2488                                 return "Success";
2489                  }
2490
2491         };
2492
2493         new MockUp<DownloadCsarManager>(){
2494                 @Mock
2495                 public String download(String url, String filepath) {
2496                         return "Success";
2497
2498                 }
2499                 };
2500                 new MockUp<JSONObject>(){
2501                 @Mock
2502                 public JSONObject fromObject(Object object){
2503                         JSONObject js = new JSONObject();
2504                         js.put("id", "upload-id-123");
2505                         js.put("Result", "Success");
2506                         js.put("Check", "Ok");
2507                         js.put("url", "http://localhost:80");
2508                         js.put("userName", "User");
2509                         js.put("password", "pass");
2510                         js.put("downloadUri", "http://127.0.0.1:80");
2511                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2512                         js.put("keyStorePass", "Changeme_123");
2513                         js.put("keyStoreType", "PKCS12");
2514                         JSONArray ja = new JSONArray();
2515                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2516                         ja.add(str);
2517                         JSONArray ja1 = new JSONArray();
2518                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2519                         ja1.add(str1);
2520                         JSONArray ja2 = new JSONArray();
2521                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2522                         ja2.add(str2);
2523                         JSONObject jsObject = new JSONObject();
2524                         jsObject.put("downloadUrl", "http://localhost:80");
2525                         jsObject.put("csarName", "CSCF_SI");
2526                         js.put("vim_info", ja);
2527                         js.put("template", ja2);
2528                         js.put("templates", ja1);
2529                         js.put("packageInfo", jsObject);
2530                         return js;
2531                 }
2532                 };
2533
2534                 new MockUp<DownloadCsarManager>(){
2535                 @Mock
2536                  public int unzipCSAR(String fileName, String filePath) {
2537                                 return 0;
2538
2539                 }
2540                 };
2541
2542                 new MockUp<ConnectMgrVnfm>(){
2543
2544                         @Mock
2545                          public int connect(JSONObject vnfmObj, String authModel) {
2546                                 vnfmObj.put("connToken", "accessSession");
2547                                 vnfmObj.put("Content-Type", "Application/Json");
2548                                 authModel = "accessSession";
2549                                 return 200;
2550                         }
2551
2552                 };
2553
2554                 new MockUp<HttpClient>(){
2555                         @Mock
2556                         public int executeMethod(HttpMethod method) {
2557                             return 200;
2558                         }
2559                     };
2560
2561                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2562
2563         JSONObject vnfpkg = new JSONObject();
2564         vnfpkg.put("name", "test");
2565         JSONObject obj = new JSONObject();
2566         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2567         obj.put("csar_file_name", "casrFile");
2568         vnfpkg.put("template", obj);
2569         Map<String, String> paramsMap = new HashMap<>();
2570         paramsMap.put("csarid", "csarid123");
2571         paramsMap.put("vnfmid", "vnfmid1234");
2572         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2573         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2574
2575     }
2576
2577     @Test(expected=JSONException.class)
2578     public void uploadVNFPackageTestWithMME() {
2579
2580         new MockUp<VNFRestfulUtil>(){
2581                 @Mock
2582                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2583                         RestfulResponse rr = new RestfulResponse();
2584                         Map<String, String> header = new HashMap<>();
2585                         header.put("Content-Type", "Application/Json");
2586                         header.put("X-FormId", "jhfdl");
2587                         rr.setRespHeaderMap(header);
2588                         rr.setStatus(200);
2589                         rr.setResponseJson("shdfhj");
2590
2591                         return rr;
2592
2593                 }
2594         };
2595
2596                 new MockUp<JSONObject>(){
2597                 @Mock
2598                 public JSONObject fromObject(Object object){
2599                         JSONObject js = new JSONObject();
2600                         js.put("id", "upload-id-123");
2601                         js.put("Result", "Success");
2602                         js.put("Check", "Ok");
2603                         js.put("url", "http://localhost:80");
2604                         js.put("userName", "User");
2605                         js.put("password", "pass");
2606                         js.put("downloadUri", "http://127.0.0.1:80");
2607                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2608                         js.put("keyStorePass", "Changeme_123");
2609                         js.put("keyStoreType", "PKCS12");
2610                         JSONArray ja = new JSONArray();
2611                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2612                         ja.add(str);
2613                         JSONArray ja1 = new JSONArray();
2614                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2615                         ja1.add(str1);
2616                         JSONArray ja2 = new JSONArray();
2617                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2618                         ja2.add(str2);
2619                         JSONObject jsObject = new JSONObject();
2620                         jsObject.put("downloadUrl", "http://localhost:80");
2621                         jsObject.put("csarName", "MME");
2622                         js.put("vim_info", ja);
2623                         js.put("template", ja2);
2624                         js.put("templates", ja1);
2625                         js.put("packageInfo", jsObject);
2626                         return js;
2627                 }
2628                 };
2629
2630                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2631
2632         JSONObject vnfpkg = new JSONObject();
2633         vnfpkg.put("name", "test");
2634         JSONObject obj = new JSONObject();
2635         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2636         obj.put("csar_file_name", "casrFile");
2637         vnfpkg.put("template", obj);
2638         Map<String, String> paramsMap = new HashMap<>();
2639         paramsMap.put("csarid", "csarid123");
2640         paramsMap.put("vnfmid", "vnfmid1234");
2641         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2642         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2643
2644     }
2645
2646     @Test(expected=JSONException.class)
2647     public void uploadVNFPackageTestWithSPGW() {
2648
2649         new MockUp<VNFRestfulUtil>(){
2650                 @Mock
2651                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2652                         RestfulResponse rr = new RestfulResponse();
2653                         Map<String, String> header = new HashMap<>();
2654                         header.put("Content-Type", "Application/Json");
2655                         header.put("X-FormId", "jhfdl");
2656                         rr.setRespHeaderMap(header);
2657                         rr.setStatus(200);
2658                         rr.setResponseJson("shdfhj");
2659
2660                         return rr;
2661
2662                 }
2663         };
2664
2665                 new MockUp<JSONObject>(){
2666                 @Mock
2667                 public JSONObject fromObject(Object object){
2668                         JSONObject js = new JSONObject();
2669                         js.put("id", "upload-id-123");
2670                         js.put("Result", "Success");
2671                         js.put("Check", "Ok");
2672                         js.put("url", "http://localhost:80");
2673                         js.put("userName", "User");
2674                         js.put("password", "pass");
2675                         js.put("downloadUri", "http://127.0.0.1:80");
2676                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2677                         js.put("keyStorePass", "Changeme_123");
2678                         js.put("keyStoreType", "PKCS12");
2679                         JSONArray ja = new JSONArray();
2680                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2681                         ja.add(str);
2682                         JSONArray ja1 = new JSONArray();
2683                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2684                         ja1.add(str1);
2685                         JSONArray ja2 = new JSONArray();
2686                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2687                         ja2.add(str2);
2688                         JSONObject jsObject = new JSONObject();
2689                         jsObject.put("downloadUrl", "http://localhost:80");
2690                         jsObject.put("csarName", "SPGW");
2691                         js.put("vim_info", ja);
2692                         js.put("template", ja2);
2693                         js.put("templates", ja1);
2694                         js.put("packageInfo", jsObject);
2695                         return js;
2696                 }
2697                 };
2698
2699                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2700
2701         JSONObject vnfpkg = new JSONObject();
2702         vnfpkg.put("name", "test");
2703         JSONObject obj = new JSONObject();
2704         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2705         obj.put("csar_file_name", "casrFile");
2706         vnfpkg.put("template", obj);
2707         Map<String, String> paramsMap = new HashMap<>();
2708         paramsMap.put("csarid", "csarid123");
2709         paramsMap.put("vnfmid", "vnfmid1234");
2710         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2711         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2712
2713     }
2714
2715     @Test(expected=JSONException.class)
2716     public void uploadVNFPackageTestWithHSS() {
2717
2718         new MockUp<VNFRestfulUtil>(){
2719                 @Mock
2720                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2721                         RestfulResponse rr = new RestfulResponse();
2722                         Map<String, String> header = new HashMap<>();
2723                         header.put("Content-Type", "Application/Json");
2724                         header.put("X-FormId", "jhfdl");
2725                         rr.setRespHeaderMap(header);
2726                         rr.setStatus(200);
2727                         rr.setResponseJson("shdfhj");
2728
2729                         return rr;
2730
2731                 }
2732         };
2733
2734                 new MockUp<JSONObject>(){
2735                 @Mock
2736                 public JSONObject fromObject(Object object){
2737                         JSONObject js = new JSONObject();
2738                         js.put("id", "upload-id-123");
2739                         js.put("Result", "Success");
2740                         js.put("Check", "Ok");
2741                         js.put("url", "http://localhost:80");
2742                         js.put("userName", "User");
2743                         js.put("password", "pass");
2744                         js.put("downloadUri", "http://127.0.0.1:80");
2745                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2746                         js.put("keyStorePass", "Changeme_123");
2747                         js.put("keyStoreType", "PKCS12");
2748                         JSONArray ja = new JSONArray();
2749                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2750                         ja.add(str);
2751                         JSONArray ja1 = new JSONArray();
2752                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2753                         ja1.add(str1);
2754                         JSONArray ja2 = new JSONArray();
2755                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2756                         ja2.add(str2);
2757                         JSONObject jsObject = new JSONObject();
2758                         jsObject.put("downloadUrl", "http://localhost:80");
2759                         jsObject.put("csarName", "HSS");
2760                         js.put("vim_info", ja);
2761                         js.put("template", ja2);
2762                         js.put("templates", ja1);
2763                         js.put("packageInfo", jsObject);
2764                         return js;
2765                 }
2766                 };
2767
2768                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2769
2770         JSONObject vnfpkg = new JSONObject();
2771         vnfpkg.put("name", "test");
2772         JSONObject obj = new JSONObject();
2773         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2774         obj.put("csar_file_name", "casrFile");
2775         vnfpkg.put("template", obj);
2776         Map<String, String> paramsMap = new HashMap<>();
2777         paramsMap.put("csarid", "csarid123");
2778         paramsMap.put("vnfmid", "vnfmid1234");
2779         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2780         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2781
2782     }
2783
2784     @Test(expected=JSONException.class)
2785     public void uploadVNFPackageTestWithSBC() {
2786
2787         new MockUp<VNFRestfulUtil>(){
2788                 @Mock
2789                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2790                         RestfulResponse rr = new RestfulResponse();
2791                         Map<String, String> header = new HashMap<>();
2792                         header.put("Content-Type", "Application/Json");
2793                         header.put("X-FormId", "jhfdl");
2794                         rr.setRespHeaderMap(header);
2795                         rr.setStatus(200);
2796                         rr.setResponseJson("shdfhj");
2797
2798                         return rr;
2799
2800                 }
2801         };
2802
2803                 new MockUp<JSONObject>(){
2804                 @Mock
2805                 public JSONObject fromObject(Object object){
2806                         JSONObject js = new JSONObject();
2807                         js.put("id", "upload-id-123");
2808                         js.put("Result", "Success");
2809                         js.put("Check", "Ok");
2810                         js.put("url", "http://localhost:80");
2811                         js.put("userName", "User");
2812                         js.put("password", "pass");
2813                         js.put("downloadUri", "http://127.0.0.1:80");
2814                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2815                         js.put("keyStorePass", "Changeme_123");
2816                         js.put("keyStoreType", "PKCS12");
2817                         JSONArray ja = new JSONArray();
2818                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2819                         ja.add(str);
2820                         JSONArray ja1 = new JSONArray();
2821                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2822                         ja1.add(str1);
2823                         JSONArray ja2 = new JSONArray();
2824                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2825                         ja2.add(str2);
2826                         JSONObject jsObject = new JSONObject();
2827                         jsObject.put("downloadUrl", "http://localhost:80");
2828                         jsObject.put("csarName", "SBC");
2829                         js.put("vim_info", ja);
2830                         js.put("template", ja2);
2831                         js.put("templates", ja1);
2832                         js.put("packageInfo", jsObject);
2833                         return js;
2834                 }
2835                 };
2836
2837                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2838
2839         JSONObject vnfpkg = new JSONObject();
2840         vnfpkg.put("name", "test");
2841         JSONObject obj = new JSONObject();
2842         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2843         obj.put("csar_file_name", "casrFile");
2844         vnfpkg.put("template", obj);
2845         Map<String, String> paramsMap = new HashMap<>();
2846         paramsMap.put("csarid", "csarid123");
2847         paramsMap.put("vnfmid", "vnfmid1234");
2848         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2849         assertTrue(res.get("reason").equals("RestfulResponse is null."));
2850
2851     }
2852
2853     @Test(expected=JSONException.class)
2854     public void uploadVNFPackageTestWithPCRF() {
2855
2856                 new MockUp<VNFRestfulUtil>(){
2857                         @Mock
2858                         public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2859                                 RestfulResponse rr = new RestfulResponse();
2860                                 Map<String, String> header = new HashMap<>();
2861                                 header.put("Content-Type", "Application/Json");
2862                                 header.put("X-FormId", "jhfdl");
2863                                 rr.setRespHeaderMap(header);
2864                                 rr.setStatus(200);
2865                                 rr.setResponseJson("shdfhj");
2866
2867                                 return rr;
2868
2869                         }
2870                 };
2871
2872                 new MockUp<JSONObject>(){
2873                 @Mock
2874                 public JSONObject fromObject(Object object){
2875                         JSONObject js = new JSONObject();
2876                         js.put("id", "upload-id-123");
2877                         js.put("Result", "Success");
2878                         js.put("Check", "Ok");
2879                         js.put("url", "http://localhost:80");
2880                         js.put("userName", "User");
2881                         js.put("password", "pass");
2882                         js.put("downloadUri", "http://127.0.0.1:80");
2883                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2884                         js.put("keyStorePass", "Changeme_123");
2885                         js.put("keyStoreType", "PKCS12");
2886                         JSONArray ja = new JSONArray();
2887                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2888                         ja.add(str);
2889                         JSONArray ja1 = new JSONArray();
2890                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2891                         ja1.add(str1);
2892                         JSONArray ja2 = new JSONArray();
2893                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2894                         ja2.add(str2);
2895                         JSONObject jsObject = new JSONObject();
2896                         jsObject.put("downloadUrl", "http://localhost:80");
2897                         jsObject.put("csarName", "PCRF");
2898                         js.put("vim_info", ja);
2899                         js.put("template", ja2);
2900                         js.put("templates", ja1);
2901                         js.put("packageInfo", jsObject);
2902                         return js;
2903                 }
2904                 };
2905
2906         System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2907
2908         JSONObject vnfpkg = new JSONObject();
2909         vnfpkg.put("name", "test");
2910         JSONObject obj = new JSONObject();
2911         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2912         obj.put("csar_file_name", "casrFile");
2913         vnfpkg.put("template", obj);
2914         Map<String, String> paramsMap = new HashMap<>();
2915         paramsMap.put("csarid", "csarid123");
2916         paramsMap.put("vnfmid", "vnfmid1234");
2917         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2918         assertTrue(res.get("reason").equals("download csar file failed."));
2919
2920     }
2921
2922     @Test(expected=JSONException.class)
2923     public void uploadVNFPackageTestWithTAS() {
2924
2925         new MockUp<VNFRestfulUtil>(){
2926                 @Mock
2927                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2928                         RestfulResponse rr = new RestfulResponse();
2929                         Map<String, String> header = new HashMap<>();
2930                         header.put("Content-Type", "Application/Json");
2931                         header.put("X-FormId", "jhfdl");
2932                         rr.setRespHeaderMap(header);
2933                         rr.setStatus(200);
2934                         rr.setResponseJson("shdfhj");
2935
2936                         return rr;
2937
2938                 }
2939         };
2940
2941                 new MockUp<JSONObject>(){
2942                 @Mock
2943                 public JSONObject fromObject(Object object){
2944                         JSONObject js = new JSONObject();
2945                         js.put("id", "upload-id-123");
2946                         js.put("Result", "Success");
2947                         js.put("Check", "Ok");
2948                         js.put("url", "http://localhost:80");
2949                         js.put("userName", "User");
2950                         js.put("password", "pass");
2951                         js.put("downloadUri", "http://127.0.0.1:80");
2952                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
2953                         js.put("keyStorePass", "Changeme_123");
2954                         js.put("keyStoreType", "PKCS12");
2955                         JSONArray ja = new JSONArray();
2956                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
2957                         ja.add(str);
2958                         JSONArray ja1 = new JSONArray();
2959                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
2960                         ja1.add(str1);
2961                         JSONArray ja2 = new JSONArray();
2962                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
2963                         ja2.add(str2);
2964                         JSONObject jsObject = new JSONObject();
2965                         jsObject.put("downloadUrl", "http://localhost:80");
2966                         jsObject.put("csarName", "TAS");
2967                         js.put("vim_info", ja);
2968                         js.put("template", ja2);
2969                         js.put("templates", ja1);
2970                         js.put("packageInfo", jsObject);
2971                         return js;
2972                 }
2973                 };
2974
2975                 System.setProperty("catalina.base", "D:/ONAP-VFC/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
2976
2977         JSONObject vnfpkg = new JSONObject();
2978         vnfpkg.put("name", "test");
2979         JSONObject obj = new JSONObject();
2980         obj.put("csar_file_path", "src/test/resources/Check10.txt");
2981         obj.put("csar_file_name", "casrFile");
2982         vnfpkg.put("template", obj);
2983         Map<String, String> paramsMap = new HashMap<>();
2984         paramsMap.put("csarid", "csarid123");
2985         paramsMap.put("vnfmid", "vnfmid1234");
2986         JSONObject res = manager.uploadVNFPackage(vnfpkg, paramsMap);
2987         assertTrue(res.get("reason").equals("download csar file failed."));
2988
2989     }
2990
2991     @Test
2992     public void uploadVNFPackageTestWithCSCF() {
2993
2994         new MockUp<VNFRestfulUtil>(){
2995                 @Mock
2996                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
2997                         RestfulResponse rr = new RestfulResponse();
2998                         Map<String, String> header = new HashMap<>();
2999                         header.put("Content-Type", "Application/Json");
3000                         header.put("X-FormId", "jhfdl");
3001                         rr.setRespHeaderMap(header);
3002                         rr.setStatus(200);
3003                         rr.setResponseJson("shdfhj");
3004
3005                         return rr;
3006
3007                 }
3008         };
3009
3010                 new MockUp<JSONObject>(){
3011                 @Mock
3012                 public JSONObject fromObject(Object object){
3013                         JSONObject js = new JSONObject();
3014                         js.put("id", "upload-id-123");
3015                         js.put("Result", "Success");
3016                         js.put("Check", "Ok");
3017                         js.put("url", "http://localhost:80");
3018                         js.put("userName", "User");
3019                         js.put("password", "pass");
3020                         js.put("downloadUri", "http://127.0.0.1:80");
3021                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3022                         js.put("keyStorePass", "Changeme_123");
3023                         js.put("keyStoreType", "PKCS12");
3024                         JSONArray ja = new JSONArray();
3025                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3026                         ja.add(str);
3027                         JSONArray ja1 = new JSONArray();
3028                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3029                         ja1.add(str1);
3030                         JSONArray ja2 = new JSONArray();
3031                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3032                         ja2.add(str2);
3033                         JSONObject jsObject = new JSONObject();
3034                         jsObject.put("downloadUrl", "http://localhost:80");
3035                         jsObject.put("csarName", "CSCF");
3036                         JSONObject jsEms = new JSONObject();
3037                         jsEms.put("emsUuid", "123erbhi-hjdek123");
3038                         JSONObject jsCsar = new JSONObject();
3039                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3040                         jsCsar.put("csar_file_name", "Csar_File");
3041                         jsCsar.put("emsUuid", jsEms);
3042                         JSONObject jsTemp = new JSONObject();
3043                         jsTemp.put("template", jsCsar);
3044                         js.put("vCSCF", jsTemp);
3045                         js.put("vim_info", ja);
3046                         js.put("template", ja2);
3047                         js.put("templates", ja1);
3048                         js.put("packageInfo", jsObject);
3049                         return js;
3050                 }
3051                 };
3052
3053                 System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3054
3055         JSONObject vnfpkg = new JSONObject();
3056         JSONObject vnfpkg1 = new JSONObject();
3057         vnfpkg.put("name", "test");
3058         JSONObject obj = new JSONObject();
3059         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3060         obj.put("csar_file_name", "casrFile");
3061         vnfpkg.put("template", obj);
3062         Map<String, String> paramsMap = new HashMap<>();
3063         paramsMap.put("csarid", "csarid123");
3064         paramsMap.put("vnfmid", "vnfmid1234");
3065         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3066         assertTrue(res.get("reason").equals("download csar file failed."));
3067     }
3068
3069     @Test
3070     public void uploadVNFPackageTestWithOutEmsUid() {
3071
3072         new MockUp<VNFRestfulUtil>(){
3073                 @Mock
3074                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
3075                         RestfulResponse rr = new RestfulResponse();
3076                         Map<String, String> header = new HashMap<>();
3077                         header.put("Content-Type", "Application/Json");
3078                         header.put("X-FormId", "jhfdl");
3079                         rr.setRespHeaderMap(header);
3080                         rr.setStatus(200);
3081                         rr.setResponseJson("shdfhj");
3082
3083                         return rr;
3084
3085                 }
3086         };
3087
3088                 new MockUp<JSONObject>(){
3089                 @Mock
3090                 public JSONObject fromObject(Object object){
3091                         JSONObject js = new JSONObject();
3092                         js.put("id", "upload-id-123");
3093                         js.put("Result", "Success");
3094                         js.put("Check", "Ok");
3095                         js.put("url", "http://localhost:80");
3096                         js.put("userName", "User");
3097                         js.put("password", "pass");
3098                         js.put("downloadUri", "http://127.0.0.1:80");
3099                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3100                         js.put("keyStorePass", "Changeme_123");
3101                         js.put("keyStoreType", "PKCS12");
3102                         JSONArray ja = new JSONArray();
3103                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3104                         ja.add(str);
3105                         JSONArray ja1 = new JSONArray();
3106                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3107                         ja1.add(str1);
3108                         JSONArray ja2 = new JSONArray();
3109                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3110                         ja2.add(str2);
3111                         JSONObject jsObject = new JSONObject();
3112                         jsObject.put("downloadUrl", "http://localhost:80");
3113                         jsObject.put("csarName", "CSCF");
3114                         JSONObject jsCsar = new JSONObject();
3115                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3116                         jsCsar.put("csar_file_name", "Csar_File");
3117                         JSONObject jsTemp = new JSONObject();
3118                         jsTemp.put("template", jsCsar);
3119                         js.put("vCSCF", jsTemp);
3120                         js.put("vim_info", ja);
3121                         js.put("template", ja2);
3122                         js.put("templates", ja1);
3123                         js.put("packageInfo", jsObject);
3124                         return js;
3125                 }
3126                 };
3127
3128                 System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3129
3130         JSONObject vnfpkg = new JSONObject();
3131         JSONObject vnfpkg1 = new JSONObject();
3132         vnfpkg.put("name", "test");
3133         JSONObject obj = new JSONObject();
3134         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3135         obj.put("csar_file_name", "casrFile");
3136         vnfpkg.put("template", obj);
3137         Map<String, String> paramsMap = new HashMap<>();
3138         paramsMap.put("csarid", "csarid123");
3139         paramsMap.put("vnfmid", "vnfmid1234");
3140         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3141         assertTrue(res.get("reason").equals("download csar file failed."));
3142     }
3143
3144     @Test
3145     public void uploadVNFPackageTestWithCSDowCsar() {
3146
3147         new MockUp<VNFRestfulUtil>(){
3148                 @Mock
3149                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
3150                         RestfulResponse rr = new RestfulResponse();
3151                         Map<String, String> header = new HashMap<>();
3152                         header.put("Content-Type", "Application/Json");
3153                         header.put("X-FormId", "jhfdl");
3154                         rr.setRespHeaderMap(header);
3155                         rr.setStatus(200);
3156                         rr.setResponseJson("shdfhj");
3157
3158                         return rr;
3159
3160                 }
3161         };
3162
3163         new MockUp<DownloadCsarManager>(){
3164                 @Mock
3165                 public String download(String url, String filepath) {
3166                         String response = "Success";
3167                         return response;
3168                 }
3169         };
3170
3171                 new MockUp<JSONObject>(){
3172                 @Mock
3173                 public JSONObject fromObject(Object object){
3174                         JSONObject js = new JSONObject();
3175                         js.put("id", "upload-id-123");
3176                         js.put("Result", "Success");
3177                         js.put("Check", "Ok");
3178                         js.put("url", "http://localhost:80");
3179                         js.put("userName", "User");
3180                         js.put("password", "pass");
3181                         js.put("downloadUri", "http://127.0.0.1:80");
3182                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3183                         js.put("keyStorePass", "Changeme_123");
3184                         js.put("keyStoreType", "PKCS12");
3185                         JSONArray ja = new JSONArray();
3186                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3187                         ja.add(str);
3188                         JSONArray ja1 = new JSONArray();
3189                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3190                         ja1.add(str1);
3191                         JSONArray ja2 = new JSONArray();
3192                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3193                         ja2.add(str2);
3194                         JSONObject jsObject = new JSONObject();
3195                         jsObject.put("downloadUrl", "http://localhost:80");
3196                         jsObject.put("csarName", "CSCF");
3197                         JSONObject jsEms = new JSONObject();
3198                         jsEms.put("emsUuid", "123erbhi-hjdek123");
3199                         JSONObject jsCsar = new JSONObject();
3200                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3201                         jsCsar.put("csar_file_name", "Csar_File");
3202                         jsCsar.put("emsUuid", jsEms);
3203                         JSONObject jsTemp = new JSONObject();
3204                         jsTemp.put("template", jsCsar);
3205                         js.put("vCSCF", jsTemp);
3206                         js.put("vim_info", ja);
3207                         js.put("template", ja2);
3208                         js.put("templates", ja1);
3209                         js.put("packageInfo", jsObject);
3210                         return js;
3211                 }
3212                 };
3213
3214                 System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3215
3216         JSONObject vnfpkg = new JSONObject();
3217         JSONObject vnfpkg1 = new JSONObject();
3218         vnfpkg.put("name", "test");
3219         JSONObject obj = new JSONObject();
3220         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3221         obj.put("csar_file_name", "casrFile");
3222         vnfpkg.put("template", obj);
3223         Map<String, String> paramsMap = new HashMap<>();
3224         paramsMap.put("csarid", "csarid123");
3225         paramsMap.put("vnfmid", "vnfmid1234");
3226         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3227         assertTrue(res.get("reason").equals("unzip csar file failed."));
3228     }
3229
3230     @Test
3231     public void uploadVNFPackageTestWithUnZipCsar() {
3232
3233         new MockUp<VNFRestfulUtil>(){
3234                 @Mock
3235                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
3236                         RestfulResponse rr = new RestfulResponse();
3237                         Map<String, String> header = new HashMap<>();
3238                         header.put("Content-Type", "Application/Json");
3239                         header.put("X-FormId", "jhfdl");
3240                         rr.setRespHeaderMap(header);
3241                         rr.setStatus(200);
3242                         rr.setResponseJson("shdfhj");
3243                         return rr;
3244
3245                 }
3246         };
3247
3248         new MockUp<VnfmUtil>(){
3249                 @Mock
3250                 public JSONObject getVnfmById(String vnfmId) {
3251
3252                         JSONObject jsonObject = new JSONObject();
3253                         jsonObject.put("url", "https://localhost:80");
3254                         jsonObject.put("userName", "ubuntu");
3255                         jsonObject.put("password", "******");
3256                         return jsonObject;
3257
3258                 }
3259         };
3260
3261         new MockUp<DownloadCsarManager>(){
3262                 @Mock
3263                 public String download(String url, String filepath) {
3264                         String response = "Success";
3265                         return response;
3266                 }
3267
3268                 @Mock
3269                  public int unzipCSAR(String fileName, String filePath) {
3270
3271                         return 0;
3272                 }
3273         };
3274
3275         new MockUp<ConnectMgrVnfm>(){
3276                 @Mock
3277                 public int connect(JSONObject vnfmObj, String authModel) {
3278
3279
3280                         return 404;
3281
3282                 }
3283         };
3284
3285         new MockUp<JSONObject>(){
3286                 @Mock
3287                 public JSONObject fromObject(Object object){
3288                         JSONObject js = new JSONObject();
3289                         js.put("id", "upload-id-123");
3290                         js.put("Result", "Success");
3291                         js.put("Check", "Ok");
3292                         js.put("url", "http://localhost:80");
3293                         js.put("userName", "User");
3294                         js.put("password", "pass");
3295                         js.put("downloadUri", "http://127.0.0.1:80");
3296                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3297                         js.put("keyStorePass", "Changeme_123");
3298                         js.put("keyStoreType", "PKCS12");
3299                         JSONArray ja = new JSONArray();
3300                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3301                         ja.add(str);
3302                         JSONArray ja1 = new JSONArray();
3303                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3304                         ja1.add(str1);
3305                         JSONArray ja2 = new JSONArray();
3306                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3307                         ja2.add(str2);
3308                         JSONObject jsObject = new JSONObject();
3309                         jsObject.put("downloadUrl", "http://localhost:80");
3310                         jsObject.put("csarName", "CSCF");
3311                         JSONObject jsEms = new JSONObject();
3312                         jsEms.put("emsUuid", "123erbhi-hjdek123");
3313                         JSONObject jsCsar = new JSONObject();
3314                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3315                         jsCsar.put("csar_file_name", "Csar_File");
3316                         jsCsar.put("emsUuid", jsEms);
3317                         JSONObject jsTemp = new JSONObject();
3318                         jsTemp.put("template", jsCsar);
3319                         js.put("vCSCF", jsTemp);
3320                         js.put("vim_info", ja);
3321                         js.put("template", ja2);
3322                         js.put("templates", ja1);
3323                         js.put("packageInfo", jsObject);
3324                         return js;
3325                 }
3326                 };
3327
3328         System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3329
3330         JSONObject vnfpkg = new JSONObject();
3331         JSONObject vnfpkg1 = new JSONObject();
3332         vnfpkg.put("name", "test");
3333         JSONObject obj = new JSONObject();
3334         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3335         obj.put("csar_file_name", "casrFile");
3336         vnfpkg.put("template", obj);
3337         Map<String, String> paramsMap = new HashMap<>();
3338         paramsMap.put("csarid", "csarid123");
3339         paramsMap.put("vnfmid", "vnfmid1234");
3340         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3341         assertTrue(res.get("reason").equals("connect fail."));
3342     }
3343
3344     @Test(expected=JSONException.class)
3345     public void uploadVNFPackageTestWithConnectMgr() {
3346
3347         new MockUp<VNFRestfulUtil>(){
3348                 @Mock
3349                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
3350                         RestfulResponse rr = new RestfulResponse();
3351                         Map<String, String> header = new HashMap<>();
3352                         header.put("Content-Type", "Application/Json");
3353                         header.put("X-FormId", "jhfdl");
3354                         rr.setRespHeaderMap(header);
3355                         rr.setStatus(200);
3356                         rr.setResponseJson("shdfhj");
3357
3358                         return rr;
3359
3360                 }
3361         };
3362
3363         new MockUp<VnfmUtil>(){
3364                 @Mock
3365                 public JSONObject getVnfmById(String vnfmId) {
3366
3367                         JSONObject jsonObject = new JSONObject();
3368                         jsonObject.put("url", "https://localhost:80");
3369                         jsonObject.put("userName", "ubuntu");
3370                         jsonObject.put("password", "******");
3371                         return jsonObject;
3372
3373                 }
3374         };
3375
3376         new MockUp<DownloadCsarManager>(){
3377                 @Mock
3378                 public String download(String url, String filepath) {
3379                         String response = "Success";
3380                         return response;
3381                 }
3382
3383                 @Mock
3384                  public int unzipCSAR(String fileName, String filePath) {
3385
3386                         return 0;
3387                 }
3388         };
3389
3390         new MockUp<HttpClient>(){
3391                 @Mock
3392                 public int executeMethod(HttpMethod method) {
3393                     return 200;
3394                 }
3395             };
3396
3397             new MockUp<HttpMethodBase>(){
3398
3399                 @Mock
3400                  public int getStatusCode(){
3401
3402                         return 200;
3403                 }
3404
3405             };
3406
3407         new MockUp<ConnectMgrVnfm>(){
3408                 @Mock
3409                 public int connect(JSONObject vnfmObj, String authModel) {
3410
3411
3412                         return 200;
3413
3414                 }
3415
3416                 @Mock
3417                 public String getAccessSession() {
3418
3419                         return "conn";
3420                 }
3421         };
3422
3423         new MockUp<JSONObject>(){
3424                 @Mock
3425                 public JSONObject fromObject(Object object){
3426                         JSONObject js = new JSONObject();
3427                         js.put("id", "upload-id-123");
3428                         js.put("Result", "Success");
3429                         js.put("Check", "Ok");
3430                         js.put("url", "http://localhost:80");
3431                         js.put("userName", "User");
3432                         js.put("password", "pass");
3433                         js.put("downloadUri", "http://127.0.0.1:80");
3434                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3435                         js.put("keyStorePass", "Changeme_123");
3436                         js.put("keyStoreType", "PKCS12");
3437                         JSONArray ja = new JSONArray();
3438                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3439                         ja.add(str);
3440                         JSONArray ja1 = new JSONArray();
3441                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3442                         ja1.add(str1);
3443                         JSONArray ja2 = new JSONArray();
3444                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3445                         ja2.add(str2);
3446                         JSONObject jsObject = new JSONObject();
3447                         jsObject.put("downloadUrl", "http://localhost:80");
3448                         jsObject.put("csarName", "CSCF");
3449                         JSONObject jsEms = new JSONObject();
3450                         jsEms.put("emsUuid", "123erbhi-hjdek123");
3451                         JSONObject jsCsar = new JSONObject();
3452                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3453                         jsCsar.put("csar_file_name", "Csar_File");
3454                         jsCsar.put("emsUuid", jsEms);
3455                         JSONObject jsTemp = new JSONObject();
3456                         jsTemp.put("template", jsCsar);
3457                         js.put("vCSCF", jsTemp);
3458                         js.put("vim_info", ja);
3459                         js.put("template", ja2);
3460                         js.put("templates", ja1);
3461                         js.put("packageInfo", jsObject);
3462                         return js;
3463                 }
3464                 };
3465
3466         System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3467
3468         JSONObject vnfpkg = new JSONObject();
3469         JSONObject vnfpkg1 = new JSONObject();
3470         vnfpkg.put("name", "test");
3471         JSONObject obj = new JSONObject();
3472         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3473         obj.put("csar_file_name", "casrFile");
3474         vnfpkg.put("template", obj);
3475         Map<String, String> paramsMap = new HashMap<>();
3476         paramsMap.put("csarid", "csarid123");
3477         paramsMap.put("vnfmid", "vnfmid1234");
3478         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3479         assertTrue(res.get("reason").equals("RestfulResponse is null."));
3480     }
3481
3482     @Test
3483     public void uploadVNFPackageTestWithConnectMgrGetAllFail() {
3484
3485         new MockUp<VNFRestfulUtil>(){
3486                 @Mock
3487                 public RestfulResponse getRemoteResponse(Map<String, String> paramsMap, String params) {
3488                         RestfulResponse rr = new RestfulResponse();
3489                         Map<String, String> header = new HashMap<>();
3490                         header.put("Content-Type", "Application/Json");
3491                         header.put("X-FormId", "jhfdl");
3492                         rr.setRespHeaderMap(header);
3493                         rr.setStatus(200);
3494                         rr.setResponseJson("shdfhj");
3495
3496                         return rr;
3497
3498                 }
3499         };
3500
3501         new MockUp<VnfmUtil>(){
3502                 @Mock
3503                 public JSONObject getVnfmById(String vnfmId) {
3504
3505                         JSONObject jsonObject = new JSONObject();
3506                         jsonObject.put("url", "https://localhost:80");
3507                         jsonObject.put("userName", "ubuntu");
3508                         jsonObject.put("password", "******");
3509                         return jsonObject;
3510
3511                 }
3512         };
3513
3514         new MockUp<DownloadCsarManager>(){
3515                 @Mock
3516                 public String download(String url, String filepath) {
3517                         String response = "Success";
3518                         return response;
3519                 }
3520
3521                 @Mock
3522                  public int unzipCSAR(String fileName, String filePath) {
3523
3524                         return 0;
3525                 }
3526         };
3527
3528         new MockUp<ConnectMgrVnfm>(){
3529                 @Mock
3530                 public int connect(JSONObject vnfmObj, String authModel) {
3531
3532
3533                         return 200;
3534
3535                 }
3536
3537                 @Mock
3538                 public String getAccessSession() {
3539
3540                         return "conn";
3541                 }
3542         };
3543
3544         new MockUp<JSONObject>(){
3545                 @Mock
3546                 public JSONObject fromObject(Object object){
3547                         JSONObject js = new JSONObject();
3548                         js.put("id", "upload-id-123");
3549                         js.put("Result", "Success");
3550                         js.put("Check", "Ok");
3551                         js.put("url", "http://localhost:80");
3552                         js.put("userName", "User");
3553                         js.put("password", "pass");
3554                         js.put("downloadUri", "http://127.0.0.1:80");
3555                         js.put("keyStore", "C:/Users/Huawei/Desktop/etc/conf/server.p12");
3556                         js.put("keyStorePass", "Changeme_123");
3557                         js.put("keyStoreType", "PKCS12");
3558                         JSONArray ja = new JSONArray();
3559                         String str = "{\n  \"vim_id\": \"vim-0-1\",\n\t\"vim-info\": {\n\t\t\"vim-name\": \"vim-name-123\",\n\t\t\"vim-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";
3560                         ja.add(str);
3561                         JSONArray ja1 = new JSONArray();
3562                         String str1 = "{\n  \"vnfdVersion\": \"1.0version\",\n\t\"vnfd-info\": {\n\t\t\"vnfd-name\": \"vnfd-name-123\",\n\t\t\"vnfd-id\": \"vim-0-1\",\n\t\t\"ip\": \"127.0.0.1\",\n\t\t\"port\": \"8482\",\n\t\t\"protocol\": \"http\",\n\t\t\n\t}\n}";;
3563                         ja1.add(str1);
3564                         JSONArray ja2 = new JSONArray();
3565                         String str2 = "{\n  \"template_name\": \"vnfd-name-123\",\n  \"topology_template\": [{\n\t\t\t\"service_url\": \"/api/hwvnfm/v1\",\n\t\t\t\n\t\t}]\n\t\n\t\n}";
3566                         ja2.add(str2);
3567                         JSONObject jsObject = new JSONObject();
3568                         jsObject.put("downloadUrl", "http://localhost:80");
3569                         jsObject.put("csarName", "CSCF");
3570                         JSONObject jsEms = new JSONObject();
3571                         jsEms.put("emsUuid", "123erbhi-hjdek123");
3572                         JSONObject jsCsar = new JSONObject();
3573                         jsCsar.put("csar_file_path", "/home/ubuntu/check/");
3574                         jsCsar.put("csar_file_name", "Csar_File");
3575                         jsCsar.put("emsUuid", jsEms);
3576                         JSONObject jsTemp = new JSONObject();
3577                         jsTemp.put("template", jsCsar);
3578                         js.put("vCSCF", jsTemp);
3579                         js.put("vim_info", ja);
3580                         js.put("template", ja2);
3581                         js.put("templates", ja1);
3582                         js.put("packageInfo", jsObject);
3583                         return js;
3584                 }
3585                 };
3586
3587         System.setProperty("catalina.base", "D:/VFC/23-08-2018/svnfm/huawei/vnfmadapter/VnfmadapterService/deployment/src/main/release");
3588
3589         JSONObject vnfpkg = new JSONObject();
3590         JSONObject vnfpkg1 = new JSONObject();
3591         vnfpkg.put("name", "test");
3592         JSONObject obj = new JSONObject();
3593         obj.put("csar_file_path", "src/test/resources/Check10.txt");
3594         obj.put("csar_file_name", "casrFile");
3595         vnfpkg.put("template", obj);
3596         Map<String, String> paramsMap = new HashMap<>();
3597         paramsMap.put("csarid", "csarid123");
3598         paramsMap.put("vnfmid", "vnfmid1234");
3599         JSONObject res = manager.uploadVNFPackage(vnfpkg1, paramsMap);
3600         assertTrue(res.get("reason").equals("get allcloud failed and IOException.Connection refused: connect"));
3601     }
3602
3603 }