huawei/vnfmadapter/VnfmadapterService/service/src/test/java/org/onap/vfc/nfvo/vnfm/svnfm/vnfmadapter/service/rest/VnfRoaTest.java

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