gerrit.onap Code Review - vfc/nfvo/driver/vnfm/svnfm.git/blob

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