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.rest;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertNotNull;
  21
  22 import java.io.IOException;
  23
  24 import javax.servlet.http.HttpServletRequest;
  25 import javax.servlet.http.HttpServletResponse;
  26
  27 import org.junit.After;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmJsonUtil;
  31 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.VnfmUtil;
  32 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.common.restclient.ServiceException;
  33 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.constant.Constant;
  34 import org.onap.vfc.nfvo.vnfm.svnfm.vnfmadapter.service.process.VnfMgr;
  35
  36 import mockit.Mock;
  37 import mockit.MockUp;
  38 import net.sf.json.JSONArray;
  39 import net.sf.json.JSONObject;
  40
  41 public class VnfRoaTest {
  42
  43     private VnfRoa vnfRoa;
  44
  45     private VnfMgr vnfMgr;
  46
  47     @Before
  48     public void setUp() {
  49         vnfRoa = new VnfRoa();
  50         vnfMgr = new VnfMgr();
  51         vnfRoa.setVnfMgr(vnfMgr);
  52     }
  53
  54     @After
  55     public void tearDown() {
  56         vnfRoa = null;
  57         vnfMgr = null;
  58     }
  59
  60     @Test
  61     public void testAddVnf() throws ServiceException {
  62         final JSONObject restJson = new JSONObject();
  63         restJson.put("retCode", Constant.REST_SUCCESS);
  64         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
  65         HttpServletRequest mockInstance = proxyStub.getMockInstance();
  66
  67         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
  68         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
  69
  70         new MockUp<VnfMgr>() {
  71
  72             @Mock
  73             public JSONObject addVnf(JSONObject subJsonObject, String vnfmId) {
  74                 JSONObject retJson = new JSONObject();
  75                 retJson.put("id", "123");
  76                 restJson.put("data", retJson);
  77                 return restJson;
  78             }
  79         };
  80         new MockUp<VnfmJsonUtil>() {
  81
  82             @SuppressWarnings("unchecked")
  83             @Mock
  84             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
  85                 return (T)restJson;
  86             }
  87         };
  88
  89         String result = vnfRoa.addVnf(mockInstance, mockResInstance, "vnfmId");
  90
  91         JSONObject retJson = new JSONObject();
  92         retJson.put("id", "123");
  93         assertEquals(retJson.toString(), result);
  94
  95     }
  96
  97     @Test
  98     public void testAddVnfFail() throws ServiceException {
  99         final JSONObject restJson = new JSONObject();
 100         restJson.put("retCode", Constant.REST_FAIL);
 101         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 102         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 103
 104         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 105         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 106
 107         new MockUp<VnfMgr>() {
 108
 109             @Mock
 110             public JSONObject addVnf(JSONObject subJsonObject, String vnfmId) {
 111                 return restJson;
 112             }
 113         };
 114         new MockUp<VnfmJsonUtil>() {
 115
 116             @SuppressWarnings("unchecked")
 117             @Mock
 118             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 119                 return (T)restJson;
 120             }
 121         };
 122
 123         String result = vnfRoa.addVnf(mockInstance, mockResInstance, "vnfmId");
 124
 125         assertEquals(restJson.toString(), result);
 126
 127     }
 128
 129     @Test
 130     public void testAddVnfBySubJsonObjectNull() throws ServiceException {
 131         final JSONObject restJson = new JSONObject();
 132         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 133         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 134
 135         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 136         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 137
 138         new MockUp<VnfmJsonUtil>() {
 139
 140             @Mock
 141             public <T> T getJsonFromContexts(HttpServletRequest context) {
 142                 return null;
 143             }
 144         };
 145
 146         String result = vnfRoa.addVnf(mockInstance, mockResInstance, "vnfmId");
 147
 148         assertEquals(restJson.toString(), result);
 149
 150     }
 151
 152     @Test
 153     public void testDelVnf() throws ServiceException {
 154         final JSONObject restJson = new JSONObject();
 155         restJson.put("retCode", Constant.REST_SUCCESS);
 156         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 157         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 158
 159         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 160         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 161
 162         new MockUp<VnfMgr>() {
 163
 164             @Mock
 165             public JSONObject deleteVnf(String vnfId, String vnfmId, JSONObject vnfObject) {
 166                 JSONObject retJson = new JSONObject();
 167                 retJson.put("id", "123");
 168                 restJson.put("data", retJson);
 169                 return restJson;
 170             }
 171         };
 172
 173         new MockUp<VnfmJsonUtil>() {
 174
 175             @SuppressWarnings("unchecked")
 176             @Mock
 177             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 178                 return (T)restJson;
 179             }
 180         };
 181
 182         String result = vnfRoa.delVnf("vnfmId", mockResInstance, "vnfId", mockInstance);
 183         JSONObject retJson = new JSONObject();
 184         retJson.put("id", "123");
 185         assertEquals(retJson.toString(), result);
 186     }
 187
 188     @Test
 189     public void testDelVnfByVnfIdIsEmpty() throws ServiceException {
 190         final JSONObject restJson = new JSONObject();
 191         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 192         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 193
 194         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 195         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 196
 197         new MockUp<VnfmJsonUtil>() {
 198
 199             @SuppressWarnings("unchecked")
 200             @Mock
 201             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 202                 return (T)restJson;
 203             }
 204         };
 205
 206         String result = vnfRoa.delVnf("vnfmId", mockResInstance, "", mockInstance);
 207
 208         assertEquals(restJson.toString(), result);
 209     }
 210
 211     @Test
 212     public void testDelVnfByVnfmIdIsEmpty() throws ServiceException {
 213         final JSONObject restJson = new JSONObject();
 214         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 215         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 216
 217         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 218         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 219
 220         new MockUp<VnfmJsonUtil>() {
 221
 222             @SuppressWarnings("unchecked")
 223             @Mock
 224             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 225                 return (T)restJson;
 226             }
 227         };
 228
 229         String result = vnfRoa.delVnf("", mockResInstance, "vnfId", mockInstance);
 230
 231         assertEquals(restJson.toString(), result);
 232     }
 233
 234     @Test
 235     public void testDelVnfByVnfIdVnfmIdEmpty() throws ServiceException {
 236         final JSONObject restJson = new JSONObject();
 237         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 238         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 239
 240         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 241         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 242
 243         new MockUp<VnfmJsonUtil>() {
 244
 245             @SuppressWarnings("unchecked")
 246             @Mock
 247             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 248                 return (T)restJson;
 249             }
 250         };
 251
 252         String result = vnfRoa.delVnf("", mockResInstance, "", mockInstance);
 253
 254         assertEquals(restJson.toString(), result);
 255     }
 256
 257     @Test
 258     public void testDelVnfFail() throws ServiceException {
 259         final JSONObject restJson = new JSONObject();
 260         restJson.put("retCode", Constant.REST_FAIL);
 261         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 262         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 263
 264         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 265         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 266
 267         new MockUp<VnfMgr>() {
 268
 269             @Mock
 270             public JSONObject deleteVnf(String vnfId, String vnfmId, JSONObject vnfObject) {
 271                 return restJson;
 272             }
 273         };
 274
 275         new MockUp<VnfmJsonUtil>() {
 276
 277             @SuppressWarnings("unchecked")
 278             @Mock
 279             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 280                 return (T)restJson;
 281             }
 282         };
 283
 284         String result = vnfRoa.delVnf("vnfmId", mockResInstance, "vnfId", mockInstance);
 285         assertEquals(restJson.toString(), result);
 286     }
 287
 288     @Test
 289     public void testGetVnfByVnfIdIsEmpty() throws IOException, ServiceException {
 290         final JSONObject restJson = new JSONObject();
 291         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 292         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 293
 294         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 295         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 296
 297         new MockUp<VnfmJsonUtil>() {
 298
 299             @SuppressWarnings("unchecked")
 300             @Mock
 301             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 302                 return (T)restJson;
 303             }
 304         };
 305
 306         String result = vnfRoa.getVnf("vnfmId", mockResInstance, "");
 307
 308         assertEquals(restJson.toString(), result);
 309     }
 310
 311     @Test
 312     public void testGetVnfByVnfmIdIsEmpty() throws IOException, ServiceException {
 313         final JSONObject restJson = new JSONObject();
 314         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 315         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 316
 317         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 318         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 319
 320         new MockUp<VnfmJsonUtil>() {
 321
 322             @SuppressWarnings("unchecked")
 323             @Mock
 324             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 325                 return (T)restJson;
 326             }
 327         };
 328
 329         String result = vnfRoa.getVnf("", mockResInstance, "vnfId");
 330
 331         assertEquals(restJson.toString(), result);
 332     }
 333
 334     @Test
 335     public void testGetVnfFail() throws IOException, ServiceException {
 336         final JSONObject restJson = new JSONObject();
 337         restJson.put("retCode", Constant.REST_FAIL);
 338         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 339         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 340
 341         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 342         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 343
 344         new MockUp<VnfMgr>() {
 345
 346             @Mock
 347             public JSONObject getVnf(String vnfId, String vnfmId) {
 348                 return restJson;
 349             }
 350         };
 351
 352         new MockUp<VnfmJsonUtil>() {
 353
 354             @SuppressWarnings("unchecked")
 355             @Mock
 356             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 357                 return (T)restJson;
 358             }
 359         };
 360
 361         String result = vnfRoa.getVnf("vnfmId", mockResInstance, "vnfId");
 362         assertEquals(restJson.toString(), result);
 363     }
 364
 365     @Test
 366     public void testGetVnf() throws IOException, ServiceException {
 367         final JSONObject restJson = new JSONObject();
 368         restJson.put("retCode", Constant.REST_SUCCESS);
 369         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 370         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 371
 372         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 373         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 374
 375         new MockUp<VnfMgr>() {
 376
 377             @Mock
 378             public JSONObject getVnf(String vnfId, String vnfmId) {
 379                 JSONObject retJson = new JSONObject();
 380                 JSONObject basicInfoJson = new JSONObject();
 381                 basicInfoJson.put("vnfInstanceId", "123");
 382                 basicInfoJson.put("vnfInstanceName", "1");
 383                 basicInfoJson.put("vnfInstanceDescription", "vFW");
 384                 basicInfoJson.put("vnfdId", "1");
 385                 basicInfoJson.put("vnfdPackageId", "vFW");
 386                 basicInfoJson.put("version", "vFW");
 387                 basicInfoJson.put("vnfProvider", "hw");
 388                 basicInfoJson.put("vnfType", "fw");
 389                 basicInfoJson.put("vnfStatus", "active");
 390                 retJson.put("vnfInfo", basicInfoJson);
 391                 retJson.put(Constant.RETCODE, Constant.REST_SUCCESS);
 392                 return retJson;
 393             }
 394         };
 395
 396         new MockUp<VnfmJsonUtil>() {
 397
 398             @SuppressWarnings("unchecked")
 399             @Mock
 400             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 401                 return (T)restJson;
 402             }
 403         };
 404
 405         String result = vnfRoa.getVnf("vnfmId", mockResInstance, "vnfId");
 406         JSONObject basicInfoJson = new JSONObject();
 407         JSONObject retJson = new JSONObject();
 408         basicInfoJson.put("vnfInstanceId", "123");
 409         basicInfoJson.put("vnfInstanceName", "1");
 410         basicInfoJson.put("vnfInstanceDescription", "vFW");
 411         basicInfoJson.put("vnfdId", "1");
 412         basicInfoJson.put("vnfdPackageId", "vFW");
 413         basicInfoJson.put("version", "vFW");
 414         basicInfoJson.put("vnfProvider", "hw");
 415         basicInfoJson.put("vnfType", "fw");
 416         basicInfoJson.put("vnfStatus", "active");
 417         retJson.put("vnfInfo", basicInfoJson);
 418         assertEquals(retJson.toString(), result);
 419     }
 420
 421     @Test
 422     public void testGetJobByJobIdNull() throws ServiceException {
 423         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 424         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 425
 426         String result = vnfRoa.getJob(null, null, mockResInstance, "1111");
 427         assertEquals("{}", result);
 428     }
 429
 430     @Test
 431     public void testGetJobByVnfmIdNull() throws ServiceException {
 432         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 433         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 434
 435         String result = vnfRoa.getJob("123", null, mockResInstance, "1111");
 436         assertEquals("{}", result);
 437     }
 438
 439     @Test
 440     public void testGetJobByVnfMgrFail() throws ServiceException {
 441         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 442         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 443         new MockUp<VnfMgr>() {
 444
 445             @Mock
 446             public JSONObject getJob(String jobId, String vnfmId) {
 447                 JSONObject restJson = new JSONObject();
 448                 restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 449                 return restJson;
 450             }
 451         };
 452         String result = vnfRoa.getJob("123", "1234", mockResInstance, "1111");
 453         assertEquals("{\"retCode\":-1}", result);
 454     }
 455
 456     @Test
 457     public void testGetJob() throws ServiceException {
 458         new MockUp<VnfMgr>() {
 459
 460             @Mock
 461             public JSONObject getJob(String jobId, String vnfmId) {
 462                 JSONObject restJson = new JSONObject();
 463                 JSONArray data = new JSONArray();
 464                 JSONObject obj = new JSONObject();
 465                 obj.put("id", "11111");
 466                 obj.put("status", "Active");
 467                 data.add(obj);
 468                 restJson.put(Constant.RETCODE, Constant.REST_SUCCESS);
 469                 restJson.put("data", data);
 470                 return restJson;
 471             }
 472         };
 473
 474         String result = vnfRoa.getJob("123", "1234", null, "1111");
 475         assertNotNull(result);
 476     }
 477
 478     @Test
 479     public void testHealVnf() throws ServiceException {
 480         final JSONObject restJson = new JSONObject();
 481         restJson.put("retCode", Constant.REST_SUCCESS);
 482         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 483         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 484
 485         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 486         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 487
 488         new MockUp<VnfMgr>() {
 489
 490             @Mock
 491             public JSONObject healVnf(JSONObject jsonObject, String vnfInstanceId, String vnfmId)  {
 492                 JSONObject retJson = new JSONObject();
 493                 retJson.put("id", "123");
 494                 restJson.put("data", retJson);
 495                 return restJson;
 496             }
 497         };
 498         new MockUp<VnfmJsonUtil>() {
 499
 500             @SuppressWarnings("unchecked")
 501             @Mock
 502             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 503                 return (T)restJson;
 504             }
 505         };
 506
 507         String result = vnfRoa.healVnf(mockInstance, mockResInstance, "id", "id");
 508         assertNotNull(result);
 509
 510     }
 511
 512     @Test
 513     public void testScaleVnf() throws ServiceException {
 514         final JSONObject restJson = new JSONObject();
 515         restJson.put("retCode", Constant.REST_SUCCESS);
 516         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 517         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 518
 519         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 520         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 521
 522         new MockUp<VnfMgr>() {
 523
 524             @Mock
 525             public JSONObject scaleVNF(JSONObject vnfObject, String vnfmId, String vnfInstanceId) {
 526                 JSONObject retJson = new JSONObject();
 527                 retJson.put("id", "123");
 528                 restJson.put("data", retJson);
 529                 return restJson;
 530             }
 531         };
 532         new MockUp<VnfmJsonUtil>() {
 533
 534             @SuppressWarnings("unchecked")
 535             @Mock
 536             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 537                 return (T)restJson;
 538             }
 539         };
 540
 541         String result = vnfRoa.scaleVnf(mockInstance, mockResInstance, "id", "id");
 542
 543         JSONObject retJson = new JSONObject();
 544         retJson.put("id", "123");
 545         assertEquals(retJson.toString(), result);
 546
 547     }
 548
 549     @Test
 550     public void testScaleVnfFail() throws ServiceException {
 551         final JSONObject restJson = new JSONObject();
 552         restJson.put("retCode", Constant.REST_FAIL);
 553         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 554         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 555
 556         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 557         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 558
 559         new MockUp<VnfMgr>() {
 560
 561             @Mock
 562             public JSONObject scaleVNF(JSONObject vnfObject, String vnfmId, String vnfInstanceId) {
 563                 JSONObject retJson = new JSONObject();
 564                 retJson.put("id", "123");
 565                 restJson.put("data", retJson);
 566                 return restJson;
 567             }
 568         };
 569         new MockUp<VnfmJsonUtil>() {
 570
 571             @SuppressWarnings("unchecked")
 572             @Mock
 573             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 574                 return (T)restJson;
 575             }
 576         };
 577         String result = vnfRoa.scaleVnf(mockInstance, mockResInstance, "id", "id");
 578
 579         assertEquals(restJson.toString(), result);
 580
 581     }
 582
 583     @Test
 584     public void testScaleVnfFail2() throws ServiceException {
 585         final JSONObject restJson = new JSONObject();
 586         restJson.put("retCode", Constant.REST_FAIL);
 587         MockUp<HttpServletRequest> proxyStub = new MockUp<HttpServletRequest>() {};
 588         HttpServletRequest mockInstance = proxyStub.getMockInstance();
 589
 590         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 591         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 592
 593         new MockUp<VnfMgr>() {
 594
 595             @Mock
 596             public JSONObject scaleVNF(JSONObject vnfObject, String vnfmId, String vnfInstanceId) {
 597                 JSONObject retJson = new JSONObject();
 598                 retJson.put("id", "123");
 599                 restJson.put("data", retJson);
 600                 return restJson;
 601             }
 602         };
 603         new MockUp<VnfmJsonUtil>() {
 604
 605             @SuppressWarnings("unchecked")
 606             @Mock
 607             public <T> T getJsonFromContexts(HttpServletRequest VNFreq) {
 608                 return null;
 609             }
 610         };
 611         String result = vnfRoa.scaleVnf(mockInstance, mockResInstance, "id", "id");
 612
 613         assertNotNull(result);
 614
 615     }
 616
 617     @Test
 618     public void testGetVnfmById() throws ServiceException {
 619         new MockUp<VnfmUtil>() {
 620
 621             @Mock
 622             public JSONObject getVnfmById(String vnfmId) {
 623                 JSONObject json = new JSONObject();
 624                 json.put("vnfm", "1234");
 625                 return json;
 626             }
 627         };
 628         String result = vnfRoa.getVnfmById("1234", null);
 629         assertNotNull(result);
 630     }
 631
 632     @Test
 633     public void testGetJobFromVnfm() throws ServiceException {
 634         new MockUp<VnfMgr>() {
 635
 636             @Mock
 637             public JSONObject getJobFromVnfm(String jobId, String vnfmId) {
 638                 JSONObject json = new JSONObject();
 639                 json.put("retCode", "1");
 640                 return json;
 641             }
 642
 643             @Mock
 644             public String transferToLcm(JSONObject restJson) {
 645                 return "success";
 646             }
 647         };
 648         String result = vnfRoa.getJobFromVnfm("jobId", "vnfmId", null, "responseId");
 649         assertNotNull(result);
 650     }
 651
 652     @Test
 653     public void testGetJobFromVnfmFail() throws ServiceException {
 654
 655         new MockUp<VnfMgr>() {
 656
 657             @Mock
 658             public JSONObject getJobFromVnfm(String jobId, String vnfmId) {
 659                 JSONObject json = new JSONObject();
 660                 json.put("retCode", "-1");
 661                 return json;
 662             }
 663
 664         };
 665         MockUp<HttpServletResponse> proxyResStub = new MockUp<HttpServletResponse>() {};
 666         HttpServletResponse mockResInstance = proxyResStub.getMockInstance();
 667         String result = vnfRoa.getJobFromVnfm("jobId", "vnfmId", mockResInstance, "responseId");
 668         assertNotNull(result);
 669     }
 670
 671 }