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