gerrit.onap Code Review - vfc/nfvo/resmanagement.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.openo.nfvo.resmanagement.service.business.impl;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.junit.Assert.assertNull;
  21 import static org.junit.Assert.assertTrue;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.openo.baseservice.remoteservice.exception.ServiceException;
  31 import org.openo.nfvo.resmanagement.service.dao.impl.SitesDaoImpl;
  32 import org.openo.nfvo.resmanagement.service.entity.SitesEntity;
  33
  34 import mockit.Mock;
  35 import mockit.MockUp;
  36
  37 /**
  38  * <br/>
  39  * <p>
  40  * </p>
  41  *
  42  * @author
  43  * @version NFVO 0.5 2016年8月16日
  44  */
  45 public class SitesBusinessImplTest {
  46
  47     private SitesBusinessImpl sitesBusinessImpl;
  48
  49     @Before
  50     public void setUp() {
  51         sitesBusinessImpl = new SitesBusinessImpl();
  52         sitesBusinessImpl.setSitesDao(new SitesDaoImpl());
  53     }
  54
  55     @Test
  56     public void testGetSitesIdIsNull() throws ServiceException {
  57         try {
  58             sitesBusinessImpl.getSite(null);
  59         } catch(ServiceException e) {
  60             assertTrue(true);
  61         }
  62     }
  63
  64     @Test
  65     public void testGetSite() throws ServiceException {
  66         SitesEntity sitesEntity = new SitesEntity();
  67         sitesEntity.setId("123");
  68         new MockUp<SitesDaoImpl>() {
  69
  70             @Mock
  71             public SitesEntity getSite(String id) {
  72                 SitesEntity sitesEntity = new SitesEntity();
  73                 sitesEntity.setId("123");
  74                 return sitesEntity;
  75             }
  76         };
  77         SitesEntity result = sitesBusinessImpl.getSite("id");
  78         SitesEntity expectedResult = sitesEntity;
  79         assertEquals(expectedResult.toString(), result.toString());
  80     }
  81
  82     @Test
  83     public void testGetSites() throws ServiceException {
  84         Map<String, Object> condition = new HashMap<String, Object>();
  85         SitesBusinessImpl sitesBusinessImpl = new SitesBusinessImpl();
  86         sitesBusinessImpl.setSitesDao(new SitesDaoImpl());
  87         new MockUp<SitesDaoImpl>() {
  88
  89             @Mock
  90             public List<SitesEntity> getSites(Map<String, Object> condition) {
  91                 return null;
  92             }
  93         };
  94         List<SitesEntity> result = sitesBusinessImpl.getSites(condition);
  95         assertNull(result);
  96     }
  97
  98     @Test
  99     public void testDeleteSiteEmpty() throws ServiceException {
 100         SitesBusinessImpl sitesBusinessImpl = new SitesBusinessImpl();
 101         sitesBusinessImpl.setSitesDao(new SitesDaoImpl());
 102         try {
 103             sitesBusinessImpl.deleteSite("");
 104         } catch(ServiceException e) {
 105             assertTrue(true);
 106         }
 107     }
 108
 109     @Test
 110     public void testDeleteSite() throws ServiceException {
 111         new MockUp<SitesDaoImpl>() {
 112
 113             @Mock
 114             public SitesEntity getSite(String id) {
 115                 return null;
 116             }
 117
 118             @Mock
 119             public int deleteSite(String id) {
 120                 return 1;
 121             }
 122         };
 123         int result = sitesBusinessImpl.deleteSite("007");
 124         int expectedResult = 1;
 125         assertEquals(expectedResult, result);
 126     }
 127
 128     @Test
 129     public void testAddSiteSitesEntityIsNull() throws ServiceException {
 130         try {
 131             sitesBusinessImpl.addSite(null);
 132         } catch(ServiceException e) {
 133             assertTrue(true);
 134         }
 135     }
 136
 137     @Test
 138     public void testCheckSiteExceptions() throws ServiceException {
 139         SitesEntity sitesEntity = new SitesEntity();
 140         sitesEntity.setCountry("country");
 141         sitesEntity.setId("id");
 142         sitesEntity.setLocation("location");
 143         sitesEntity.setName("name");
 144         sitesEntity.setStatus("siteStatus");
 145         sitesEntity.setTotalCPU("12");
 146         sitesEntity.setTotalDisk("12");
 147         sitesEntity.setTotalMemory("134");
 148         sitesEntity.setUsedCPU("12");
 149         sitesEntity.setUsedDisk("23");
 150         sitesEntity.setUsedMemory("10");
 151         sitesEntity.setVimId("siteVimId");
 152         sitesEntity.setVimName("siteVimName");
 153         new MockUp<SitesDaoImpl>() {
 154
 155             int count1 = 0;
 156
 157             @Mock
 158             public SitesEntity getSite(String id) {
 159                 return null;
 160             }
 161
 162             @Mock
 163             public List<SitesEntity> getSites(Map<String, Object> condition) {
 164                 if(count1 == 0) {
 165                     count1 += 1;
 166                     return null;
 167                 }
 168                 return new ArrayList<SitesEntity>();
 169
 170             }
 171         };
 172         new MockUp<SitesEntity>() {
 173
 174             @Mock
 175             public boolean checkResource(SitesEntity siteEntity) {
 176                 return false;
 177             }
 178         };
 179         try {
 180             sitesBusinessImpl.addSite(sitesEntity);
 181         } catch(ServiceException se) {
 182             assertTrue(true);
 183         }
 184     }
 185
 186     @Test
 187     public void testCheckSiteExceptions1() throws ServiceException {
 188         SitesEntity sitesEntity = new SitesEntity();
 189         sitesEntity.setCountry("country");
 190         sitesEntity.setId("id");
 191         sitesEntity.setLocation("location");
 192         sitesEntity.setName("name");
 193         sitesEntity.setStatus("siteStatus");
 194         sitesEntity.setTotalCPU("12");
 195         sitesEntity.setTotalDisk("12");
 196         sitesEntity.setTotalMemory("134");
 197         sitesEntity.setUsedCPU("12");
 198         sitesEntity.setUsedDisk("23");
 199         sitesEntity.setUsedMemory("10");
 200         sitesEntity.setVimId("siteVimId");
 201         sitesEntity.setVimName("siteVimName");
 202         new MockUp<SitesDaoImpl>() {
 203
 204             int count1 = 0;
 205
 206             @Mock
 207             public SitesEntity getSite(String id) {
 208                 return null;
 209             }
 210
 211             @Mock
 212             public List<SitesEntity> getSites(Map<String, Object> condition) {
 213
 214                 return null;
 215
 216             }
 217         };
 218         new MockUp<SitesEntity>() {
 219
 220             @Mock
 221             public boolean checkResource(SitesEntity siteEntity) {
 222                 return false;
 223             }
 224         };
 225         try {
 226             sitesBusinessImpl.addSite(sitesEntity);
 227         } catch(ServiceException se) {
 228             assertTrue(true);
 229         }
 230     }
 231
 232     @Test
 233     public void testCheckSiteExceptions2() throws ServiceException {
 234         SitesEntity sitesEntity = new SitesEntity();
 235         sitesEntity.setCountry("");
 236         sitesEntity.setId("id");
 237         sitesEntity.setLocation("");
 238         sitesEntity.setName("");
 239         sitesEntity.setStatus("siteStatus");
 240         sitesEntity.setTotalCPU("12");
 241         sitesEntity.setTotalDisk("12");
 242         sitesEntity.setTotalMemory("134");
 243         sitesEntity.setUsedCPU("12");
 244         sitesEntity.setUsedDisk("23");
 245         sitesEntity.setUsedMemory("10");
 246         sitesEntity.setVimId("siteVimId");
 247         sitesEntity.setVimName("siteVimName");
 248         new MockUp<SitesDaoImpl>() {
 249
 250             int count1 = 0;
 251
 252             @Mock
 253             public SitesEntity getSite(String id) {
 254                 return null;
 255             }
 256
 257             @Mock
 258             public List<SitesEntity> getSites(Map<String, Object> condition) {
 259
 260                 return null;
 261
 262             }
 263         };
 264         new MockUp<SitesEntity>() {
 265
 266             @Mock
 267             public boolean checkResource(SitesEntity siteEntity) {
 268                 return false;
 269             }
 270         };
 271         try {
 272             sitesBusinessImpl.addSite(sitesEntity);
 273         } catch(ServiceException se) {
 274             assertTrue(true);
 275         }
 276     }
 277
 278     @Test
 279     public void testCheckSiteNameExceptions() throws ServiceException {
 280         SitesEntity sitesEntity = new SitesEntity();
 281         sitesEntity.setId("123");
 282         sitesEntity.setCountry("china");
 283         sitesEntity.setName("openstack");
 284         sitesEntity.setLocation("xian");
 285         new MockUp<SitesDaoImpl>() {
 286
 287             @Mock
 288             public SitesEntity getSite(String id) {
 289                 return null;
 290             }
 291
 292             @Mock
 293             public List<SitesEntity> getSites(Map<String, Object> condition) {
 294                 List<SitesEntity> list = new ArrayList<SitesEntity>();
 295                 list.add(new SitesEntity());
 296                 return list;
 297
 298             }
 299         };
 300         try {
 301             sitesBusinessImpl.addSite(sitesEntity);
 302         } catch(ServiceException se) {
 303             assertTrue(true);
 304         }
 305     }
 306
 307     @Test
 308     public void testCheckIdExceptions() throws ServiceException {
 309         SitesEntity sitesEntity = new SitesEntity();
 310         sitesEntity.setId("123");
 311         sitesEntity.setCountry("china");
 312         sitesEntity.setName("openstack");
 313         sitesEntity.setLocation("xian");
 314         new MockUp<SitesDaoImpl>() {
 315
 316             @Mock
 317             public SitesEntity getSite(String id) {
 318                 return new SitesEntity();
 319             }
 320         };
 321         try {
 322             sitesBusinessImpl.addSite(sitesEntity);
 323         } catch(ServiceException se) {
 324             assertTrue(true);
 325         }
 326     }
 327
 328     @Test
 329     public void testAddSiteSelectiveSitesEntityIsNull() throws ServiceException {
 330         try {
 331             sitesBusinessImpl.addSiteSelective(null);
 332         } catch(ServiceException se) {
 333             assertTrue(true);
 334         }
 335     }
 336
 337     @Test
 338     public void testUpdateSiteSelectiveSitesEntityIsNull() throws ServiceException {
 339         try {
 340             sitesBusinessImpl.updateSiteSelective(null);
 341         } catch(ServiceException se) {
 342             assertTrue(true);
 343         }
 344     }
 345
 346     @Test
 347     public void testUpdateSiteSitesEntityIsNull() throws ServiceException {
 348         try {
 349             sitesBusinessImpl.updateSite(null);
 350         } catch(ServiceException se) {
 351             assertTrue(true);
 352         }
 353     }
 354
 355     @Test
 356     public void testUpdateSiteByVimIdSitesEntityIsNull() throws ServiceException {
 357         try {
 358             sitesBusinessImpl.updateSiteByVimId(null);
 359         } catch(ServiceException se) {
 360             assertTrue(true);
 361         }
 362     }
 363
 364     @Test
 365     public void testUpdateSiteByVimId() throws ServiceException {
 366         SitesEntity sitesEntity = new SitesEntity();
 367         sitesEntity.setCountry("china");
 368         sitesEntity.setName("openstack");
 369         sitesEntity.setLocation("xian");
 370         new MockUp<SitesDaoImpl>() {
 371
 372             @Mock
 373             public int updateSiteByVimId(SitesEntity sitesEntity) {
 374                 return 1;
 375             }
 376         };
 377         int result = sitesBusinessImpl.updateSiteByVimId(sitesEntity);
 378         int expectedResult = 1;
 379         assertEquals(expectedResult, result);
 380     }
 381
 382     @Test
 383     public void testUpdateSiteResourceSitesEntityIsNull() throws ServiceException {
 384         try {
 385             sitesBusinessImpl.updateSiteResource(null);
 386         } catch(ServiceException se) {
 387             assertTrue(true);
 388         }
 389     }
 390
 391     @Test
 392     public void testUpdateSiteResource() throws ServiceException {
 393         SitesEntity sitesEntity = new SitesEntity();
 394         sitesEntity.setCountry("china");
 395         sitesEntity.setName("openstack");
 396         sitesEntity.setLocation("xian");
 397         new MockUp<SitesDaoImpl>() {
 398
 399             @Mock
 400             public int updateSiteSelective(SitesEntity sitesEntity) {
 401                 return 1;
 402             }
 403         };
 404         int result = sitesBusinessImpl.updateSiteResource(sitesEntity);
 405         int expectedResult = 1;
 406         assertEquals(expectedResult, result);
 407     }
 408 }