huawei/vnfmadapter/VnfmadapterService/service/src/test/java/org/openo/nfvo/vnfmadapter/service/process/VnfMgrTest.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.openo.nfvo.vnfmadapter.service.process;
  18
  19 import static org.junit.Assert.assertEquals;
  20
  21 import java.util.Map;
  22
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.openo.baseservice.remoteservice.exception.ServiceException;
  26 import org.openo.nfvo.vnfmadapter.common.ResultRequestUtil;
  27 import org.openo.nfvo.vnfmadapter.common.VnfmUtil;
  28 import org.openo.nfvo.vnfmadapter.service.adapter.impl.AdapterResourceManager;
  29 import org.openo.nfvo.vnfmadapter.service.constant.Constant;
  30 import org.openo.nfvo.vnfmadapter.service.csm.vnf.VnfMgrVnfm;
  31 import org.openo.nfvo.vnfmadapter.service.dao.impl.VnfmDaoImpl;
  32 import org.openo.nfvo.vnfmadapter.service.dao.inf.VnfmDao;
  33 import org.openo.nfvo.vnfmadapter.service.entity.Vnfm;
  34
  35 import mockit.Mock;
  36 import mockit.MockUp;
  37 import net.sf.json.JSONArray;
  38 import net.sf.json.JSONException;
  39 import net.sf.json.JSONObject;
  40
  41 public class VnfMgrTest {
  42
  43     private VnfmDao vnfmDao;
  44
  45     private VnfMgr vnfMgr;
  46
  47     @Before
  48     public void setUp() {
  49         vnfMgr = new VnfMgr();
  50         vnfmDao = new VnfmDaoImpl();
  51         vnfMgr.setVnfmDao(vnfmDao);
  52     }
  53
  54     @Test
  55     public void testAddVnfByInvalidateDataVnfInfoNull() {
  56         String data = "{}";
  57         JSONObject subJsonObject = JSONObject.fromObject(data);
  58         VnfMgr vnfMgr = new VnfMgr();
  59         JSONObject result = vnfMgr.addVnf(subJsonObject, "vnmfId");
  60
  61         JSONObject restJson = new JSONObject();
  62         restJson.put("retCode", Constant.REST_FAIL);
  63         assertEquals(restJson, result);
  64     }
  65
  66     @Test
  67     public void testAddVnfByInvalidateDataVnfInfoEmpty() {
  68         String data = "{}";
  69         JSONObject subJsonObject = JSONObject.fromObject(data);
  70         VnfMgr vnfMgr = new VnfMgr();
  71         JSONObject result = vnfMgr.addVnf(subJsonObject, "vnmfId");
  72
  73         JSONObject restJson = new JSONObject();
  74         restJson.put("retCode", Constant.REST_FAIL);
  75         assertEquals(restJson, result);
  76     }
  77
  78     @Test
  79     public void testAddVnfByVnfmObjcetIsNullObject() {
  80         new MockUp<VnfmUtil>() {
  81
  82             @Mock
  83             public JSONObject getVnfmById(String vnfmId) {
  84                 return new JSONObject(true);
  85             }
  86         };
  87         String data =
  88                 "{\"soId\": \"soId\",\"vapp_info\":{\"vnfm_id\":\"vnfm_id\",\"soId\": \"soId\",\"do_id\": \"do_id\"}}";
  89         JSONObject subJsonObject = JSONObject.fromObject(data);
  90         VnfMgr vnfMgr = new VnfMgr();
  91         JSONObject result = vnfMgr.addVnf(subJsonObject, "vnmfId");
  92
  93         JSONObject restJson = new JSONObject();
  94         restJson.put("retCode", Constant.REST_FAIL);
  95         assertEquals(restJson, result);
  96     }
  97
  98     @Test
  99     public void testAddVnfByVnfmObjcetTypeEmpty() {
 100         new MockUp<VnfmUtil>() {
 101
 102             @Mock
 103             public JSONObject getVnfmById(String vnfmId) {
 104                 JSONObject obj = new JSONObject();
 105                 obj.put("type", "");
 106                 return obj;
 107             }
 108         };
 109         String data =
 110                 "{\"soId\": \"soId\",\"vapp_info\":{\"vnfm_id\":\"vnfm_id\",\"soId\": \"soId\",\"do_id\": \"do_id\"}}";
 111         JSONObject subJsonObject = JSONObject.fromObject(data);
 112         VnfMgr vnfMgr = new VnfMgr();
 113         JSONObject result = vnfMgr.addVnf(subJsonObject, "vnmfId");
 114
 115         JSONObject restJson = new JSONObject();
 116         restJson.put("retCode", Constant.REST_FAIL);
 117         assertEquals(restJson, result);
 118     }
 119
 120     @Test
 121     public void testAddVnf() {
 122         new MockUp<VnfmUtil>() {
 123
 124             @Mock
 125             public JSONObject getVnfmById(String vnfmId) {
 126                 JSONObject obj = new JSONObject();
 127                 obj.put("type", "hw");
 128                 obj.put("vnfmId", "123");
 129                 obj.put("userName", "admin");
 130                 obj.put("password", "admin");
 131                 obj.put("url", "https://10.2.31.2:30001");
 132                 return obj;
 133             }
 134         };
 135
 136         new MockUp<VnfMgrVnfm>() {
 137
 138             @Mock
 139             public JSONObject createVnf(JSONObject subJsonObject, JSONObject vnfmObjcet) {
 140                 JSONObject restJson = new JSONObject();
 141                 restJson.put("retCode", Constant.REST_SUCCESS);
 142                 return restJson;
 143             }
 144         };
 145
 146         new MockUp<AdapterResourceManager>() {
 147
 148             @Mock
 149             public JSONObject uploadVNFPackage(JSONObject subJsonObject, Map<String, String> conMap) {
 150                 JSONObject restJson = new JSONObject();
 151                 restJson.put("retCode", Constant.REST_SUCCESS);
 152                 restJson.put("vnfdId", "123");
 153                 return restJson;
 154             }
 155         };
 156
 157         String data =
 158                 "{\"vnfPackageId\": \"vnfPackageId\",\"vnfId\": \"vnfId\",\"additionalParam\":{\"parameters\":{\"input\":\"input\"}}}";
 159         JSONObject subJsonObject = JSONObject.fromObject(data);
 160         VnfMgr vnfMgr = new VnfMgr();
 161         JSONObject result = vnfMgr.addVnf(subJsonObject, "vnfmId");
 162
 163         JSONObject restJson = new JSONObject();
 164         restJson.put("retCode", Constant.REST_SUCCESS);
 165         assertEquals(restJson, result);
 166     }
 167
 168     @Test
 169     public void testDeleteVnf() {
 170         new MockUp<VnfmUtil>() {
 171
 172             @Mock
 173             public JSONObject getVnfmById(String vnfmId) {
 174                 JSONObject obj = new JSONObject();
 175                 obj.put("type", "hw");
 176                 obj.put("vnfmId", "123");
 177                 obj.put("userName", "admin");
 178                 obj.put("password", "admin");
 179                 obj.put("url", "https://10.2.31.2:30001");
 180                 return obj;
 181             }
 182         };
 183         new MockUp<VnfMgrVnfm>() {
 184
 185             @Mock
 186             public JSONObject removeVnf(JSONObject vnfmObject, String vnfId, JSONObject vnfObject) {
 187                 JSONObject obj = new JSONObject();
 188                 obj.put("retCode", Constant.REST_SUCCESS);
 189                 return obj;
 190             }
 191         };
 192         VnfMgr vnfMgr = new VnfMgr();
 193         JSONObject vnfObject = new JSONObject();
 194         JSONObject result = vnfMgr.deleteVnf("vnfId", "vnfmId", vnfObject);
 195
 196         JSONObject restJson = new JSONObject();
 197         restJson.put("retCode", Constant.REST_SUCCESS);
 198         assertEquals(restJson, result);
 199     }
 200
 201     @Test
 202     public void testDeleteVnfByVnfmObjcetIsNullObject() {
 203         new MockUp<VnfmUtil>() {
 204
 205             @Mock
 206             public JSONObject getVnfmById(String vnfmId) {
 207                 JSONObject obj = new JSONObject(true);
 208                 return obj;
 209             }
 210         };
 211         VnfMgr vnfMgr = new VnfMgr();
 212         JSONObject vnfObject = new JSONObject();
 213         JSONObject result = vnfMgr.deleteVnf("vnfId", "vnfmId", vnfObject);
 214
 215         JSONObject restJson = new JSONObject();
 216         restJson.put("retCode", Constant.REST_FAIL);
 217         assertEquals(restJson, result);
 218
 219     }
 220
 221     @Test
 222     public void testDeleteVnfByException() {
 223         new MockUp<VnfmUtil>() {
 224
 225             @Mock
 226             public JSONObject getVnfmById(String vnfmId) {
 227                 throw new JSONException();
 228             }
 229         };
 230         VnfMgr vnfMgr = new VnfMgr();
 231         JSONObject vnfObject = new JSONObject();
 232         JSONObject result = vnfMgr.deleteVnf("vnfId", "vnfmId", vnfObject);
 233
 234         JSONObject restJson = new JSONObject();
 235         restJson.put("retCode", Constant.REST_FAIL);
 236         assertEquals(restJson, result);
 237
 238     }
 239
 240     @Test
 241     public void testGetVnf() {
 242         new MockUp<VnfmUtil>() {
 243
 244             @Mock
 245             public JSONObject getVnfmById(String vnfmId) {
 246                 JSONObject obj = new JSONObject();
 247                 obj.put("type", "hw");
 248                 obj.put("vnfmId", "123");
 249                 obj.put("userName", "admin");
 250                 obj.put("password", "admin");
 251                 obj.put("url", "https://10.2.31.2:30001");
 252                 return obj;
 253             }
 254         };
 255
 256         new MockUp<VnfmDaoImpl>() {
 257
 258             @Mock
 259             public Vnfm getVnfmById(String vnfmId) {
 260                 Vnfm obj = new Vnfm();
 261                 obj.setId("123");
 262                 obj.setVersion("v2.0");
 263                 obj.setVnfdId("234");
 264                 obj.setVnfPackageId("123");
 265                 return obj;
 266             }
 267         };
 268
 269         new MockUp<ResultRequestUtil>() {
 270
 271             @Mock
 272             public JSONObject call(JSONObject vnfmObjcet, String path, String methodName, String paramsJson) {
 273                 JSONObject resultJson = new JSONObject();
 274                 resultJson.put("retCode", Constant.HTTP_OK);
 275                 JSONObject data = new JSONObject();
 276
 277                 JSONArray result = new JSONArray();
 278                 JSONObject basicInfo = new JSONObject();
 279                 basicInfo.put("id", "NE=345");
 280                 basicInfo.put("vapp_name", "sc");
 281                 basicInfo.put("status", "active");
 282                 result.add(basicInfo);
 283                 data.put("basic", result);
 284                 resultJson.put("data", data.toString());
 285                 return resultJson;
 286             }
 287         };
 288
 289         JSONObject result = vnfMgr.getVnf("vnfId", "vnfmId");
 290
 291         JSONObject restJson = new JSONObject();
 292         restJson.put("retCode", Constant.REST_SUCCESS);
 293         result.remove("vnfInfo");
 294         assertEquals(restJson, result);
 295     }
 296
 297     @Test
 298     public void testGetVnfFail() {
 299         new MockUp<VnfmUtil>() {
 300
 301             @Mock
 302             public JSONObject getVnfmById(String vnfmId) {
 303                 JSONObject obj = new JSONObject(true);
 304                 return obj;
 305             }
 306         };
 307
 308         JSONObject result = vnfMgr.getVnf("vnfId", "vnfmId");
 309         JSONObject restJson = new JSONObject();
 310         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 311         assertEquals(restJson, result);
 312     }
 313
 314     @Test
 315     public void testGetVnfFail1() {
 316         new MockUp<VnfmUtil>() {
 317
 318             @Mock
 319             public JSONObject getVnfmById(String vnfmId) {
 320                 throw new JSONException();
 321             }
 322         };
 323
 324         JSONObject result = vnfMgr.getVnf("vnfId", "vnfmId");
 325         JSONObject restJson = new JSONObject();
 326         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 327         assertEquals(restJson, result);
 328     }
 329
 330     @Test
 331     public void testSaveVnfInfo() {
 332         new MockUp<VnfmDaoImpl>() {
 333
 334             @Mock
 335             public int insertVnfm(Vnfm vnfm) throws ServiceException {
 336                 return 1;
 337             }
 338         };
 339
 340         VnfMgr vnfMgr = new VnfMgr();
 341         VnfmDao dao = new VnfmDaoImpl();
 342         vnfMgr.setVnfmDao(dao);
 343         JSONObject vnfObject = new JSONObject();
 344         vnfObject.put("retCode", Constant.REST_SUCCESS);
 345         vnfObject.put("vnfInstanceId", "vnfInstanceId");
 346         vnfObject.put("vnfPackageId", "vnfPackageId");
 347         JSONObject resObject = new JSONObject();
 348         resObject.put("vnfdVersion", "vnfdVersion");
 349         resObject.put("vnfdId", "vnfdId");
 350         vnfMgr.saveVnfInfo(vnfObject, resObject);
 351     }
 352
 353     @Test
 354     public void testSaveVnfInfoFail() {
 355         new MockUp<VnfmDaoImpl>() {
 356
 357             @Mock
 358             public int insertVnfm(Vnfm vnfm) throws ServiceException {
 359                 return 1;
 360             }
 361         };
 362
 363         VnfMgr vnfMgr = new VnfMgr();
 364         VnfmDao dao = new VnfmDaoImpl();
 365         vnfMgr.setVnfmDao(dao);
 366         JSONObject vnfObject = new JSONObject();
 367         vnfObject.put("retCode", Constant.REST_FAIL);
 368         vnfObject.put("vnfInstanceId", "vnfInstanceId");
 369         vnfObject.put("vnfPackageId", "vnfPackageId");
 370         JSONObject resObject = new JSONObject();
 371         resObject.put("vnfdVersion", "vnfdVersion");
 372         resObject.put("vnfdId", "vnfdId");
 373         vnfMgr.saveVnfInfo(vnfObject, resObject);
 374     }
 375
 376     @Test
 377     public void testSaveVnfInfoServiceException() {
 378         new MockUp<VnfmDaoImpl>() {
 379
 380             @Mock
 381             public int insertVnfm(Vnfm vnfm) throws ServiceException {
 382                 throw new ServiceException();
 383             }
 384         };
 385
 386         VnfMgr vnfMgr = new VnfMgr();
 387         VnfmDao dao = new VnfmDaoImpl();
 388         vnfMgr.setVnfmDao(dao);
 389         JSONObject vnfObject = new JSONObject();
 390         vnfObject.put("retCode", Constant.REST_SUCCESS);
 391         vnfObject.put("vnfInstanceId", "vnfInstanceId");
 392         vnfObject.put("vnfPackageId", "vnfPackageId");
 393         JSONObject resObject = new JSONObject();
 394         resObject.put("vnfdVersion", "vnfdVersion");
 395         resObject.put("vnfdId", "vnfdId");
 396         vnfMgr.saveVnfInfo(vnfObject, resObject);
 397     }
 398
 399     @Test
 400     public void testGetJob() {
 401         new MockUp<VnfmUtil>() {
 402
 403             @Mock
 404             public JSONObject getVnfmById(String vnfmId) {
 405                 JSONObject obj = new JSONObject();
 406                 obj.put("test", "success");
 407                 return obj;
 408             }
 409         };
 410
 411         new MockUp<VnfMgrVnfm>() {
 412
 413             @Mock
 414             public JSONObject getJob(JSONObject vnfmObject, String jobId) {
 415                 JSONObject res = new JSONObject();
 416                 res.put(Constant.RETCODE, Constant.REST_SUCCESS);
 417                 return res;
 418             }
 419         };
 420         VnfMgr vnfMgr = new VnfMgr();
 421         JSONObject result = vnfMgr.getJob("", "");
 422
 423         JSONObject restJson = new JSONObject();
 424         restJson.put(Constant.RETCODE, Constant.REST_SUCCESS);
 425         assertEquals(restJson, result);
 426     }
 427
 428     @Test
 429     public void testGetJobFail() {
 430         new MockUp<VnfmUtil>() {
 431
 432             @Mock
 433             public JSONObject getVnfmById(String vnfmId) {
 434                 return new JSONObject();
 435             }
 436         };
 437         VnfMgr vnfMgr = new VnfMgr();
 438         JSONObject result = vnfMgr.getJob("", "");
 439
 440         JSONObject restJson = new JSONObject();
 441         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 442         assertEquals(restJson, result);
 443     }
 444
 445     @Test
 446     public void testGetJobFail1() {
 447         new MockUp<VnfmUtil>() {
 448
 449             @Mock
 450             public JSONObject getVnfmById(String vnfmId) {
 451                 return new JSONObject(true);
 452             }
 453         };
 454         VnfMgr vnfMgr = new VnfMgr();
 455         JSONObject result = vnfMgr.getJob("", "");
 456
 457         JSONObject restJson = new JSONObject();
 458         restJson.put(Constant.RETCODE, Constant.REST_FAIL);
 459         assertEquals(restJson, result);
 460     }
 461     @Test
 462     public void testScaleVnf() {
 463         new MockUp<VnfmUtil>() {
 464
 465             @Mock
 466             public JSONObject getVnfmById(String vnfmId) {
 467                 JSONObject obj = new JSONObject();
 468                 obj.put("type", "hw");
 469                 obj.put("vnfmId", "123");
 470                 obj.put("userName", "admin");
 471                 obj.put("password", "admin");
 472                 obj.put("url", "https://10.2.31.2:30001");
 473                 return obj;
 474             }
 475         };
 476
 477         new MockUp<VnfMgrVnfm>() {
 478
 479             @Mock
 480             public JSONObject scaleVnf(JSONObject vnfObject, JSONObject vnfmObject, String vnfmId, String vnfInstanceId) {
 481                 JSONObject restJson = new JSONObject();
 482                 restJson.put("retCode", Constant.REST_SUCCESS);
 483                 return restJson;
 484             }
 485         };
 486
 487         String data =
 488                 "{\"vnfPackageId\": \"vnfPackageId\",\"vnfId\": \"vnfId\",\"additionalParam\":{\"parameters\":{\"input\":\"input\"}}}";
 489         JSONObject subJsonObject = JSONObject.fromObject(data);
 490         VnfMgr vnfMgr = new VnfMgr();
 491         JSONObject result = vnfMgr.scaleVNF(subJsonObject,"testId","testId");
 492
 493         JSONObject restJson = new JSONObject();
 494         restJson.put("retCode", Constant.REST_SUCCESS);
 495         assertEquals(restJson, result);
 496     }
 497 }