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