auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_PermLookup.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21 package org.onap.aaf.auth.dao.hl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.mockito.Mockito.when;
  25 import static org.mockito.MockitoAnnotations.initMocks;
  26
  27 import java.util.ArrayList;
  28 import java.util.Calendar;
  29 import java.util.Date;
  30 import java.util.HashSet;
  31 import java.util.List;
  32 import java.util.Properties;
  33 import java.util.Set;
  34
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.mockito.runners.MockitoJUnitRunner;
  41 import org.onap.aaf.auth.common.Define;
  42 import org.onap.aaf.auth.dao.cached.CachedRoleDAO;
  43 import org.onap.aaf.auth.dao.cached.CachedUserRoleDAO;
  44 import org.onap.aaf.auth.dao.cass.PermDAO.Data;
  45 import org.onap.aaf.auth.dao.cass.RoleDAO;
  46 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
  47 import org.onap.aaf.auth.env.AuthzTrans;
  48 import org.onap.aaf.auth.layer.Result;
  49 import org.onap.aaf.cadi.Access;
  50 import org.onap.aaf.cadi.CadiException;
  51 import org.onap.aaf.misc.env.LogTarget;
  52 import org.onap.aaf.org.DefaultOrg;
  53
  54
  55 @RunWith(MockitoJUnitRunner.class)
  56 public class JU_PermLookup {
  57
  58
  59
  60     @Mock
  61     AuthzTrans trans;
  62
  63     @Mock
  64     Question q;
  65
  66     @Mock
  67     Access access;
  68
  69     @Mock
  70     CachedRoleDAO roleDAO;
  71
  72     @Mock
  73     CachedUserRoleDAO userRoleDAO;
  74
  75     Function f;
  76
  77     @Before
  78     public void setUp() throws Exception {
  79         initMocks(this);
  80         Mockito.doReturn(userRoleDAO).when(q).userRoleDAO();
  81         Mockito.doReturn(roleDAO).when(q).roleDAO();
  82
  83         try {
  84             Mockito.doReturn("0.0").when(access).getProperty("aaf_root_ns","org.osaaf.aaf");
  85             Mockito.doReturn(new Properties()).when(access).getProperties();
  86             Define.set(access);
  87
  88             when(trans.error()).thenReturn(new LogTarget() {
  89
  90                 @Override
  91                 public void printf(String fmt, Object... vars) {}
  92
  93                 @Override
  94                 public void log(Throwable e, Object... msgs) {
  95                     e.getMessage();
  96                     e.printStackTrace();
  97                     msgs.toString();
  98
  99                 }
 100
 101                 @Override
 102                 public void log(Object... msgs) {
 103                 }
 104
 105                 @Override
 106                 public boolean isLoggable() {
 107
 108                     return true;
 109                 }
 110             });
 111         } catch (CadiException e) {
 112             // TODO Auto-generated catch block
 113             e.printStackTrace();
 114         }
 115         f =new Function(trans, q);
 116     }
 117
 118
 119 //    @Test
 120 //    public void testPerm() {
 121 //
 122 //        PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 123 //
 124 ////        System.out.println(cassExecutorObj);
 125 ////        assertFalse(retVal);
 126 //    }
 127
 128     @Test
 129     public void testGetUserRole() {
 130         @SuppressWarnings("unchecked")
 131         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 132         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 133         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 134         dataObj.expires = new Date();
 135
 136         retVal1.value.add(dataObj);
 137         Mockito.doReturn(true).when(retVal1).isOKhasData();
 138
 139         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 140
 141         DefaultOrg org = Mockito.mock(DefaultOrg.class);
 142         when(trans.org()).thenReturn(org);
 143
 144         PermLookup cassExecutorObj = PermLookup.get(trans, q,"");
 145         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 146
 147         //System.out.println(""+userRoles.status);
 148         assertEquals(24,userRoles.status);
 149     }
 150
 151     @Test
 152     public void testGetUserRolesFirstIf() {
 153         @SuppressWarnings("unchecked")
 154         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 155         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 156
 157         Mockito.doReturn(false).when(retVal1).isOKhasData();
 158         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 159
 160         DefaultOrg org = Mockito.mock(DefaultOrg.class);
 161         when(trans.org()).thenReturn(org);
 162
 163         PermLookup cassExecutorObj = PermLookup.get(trans, q,"");
 164         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 165
 166 //        System.out.println("output is"+userRoles.status);
 167         assertEquals(0,userRoles.status);
 168     }
 169
 170     @Test
 171     public void testGetUserRolesSecondIf() {
 172         @SuppressWarnings("unchecked")
 173         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 174         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 175         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 176
 177         Date dt = new Date();
 178         Calendar c = Calendar.getInstance();
 179         c.setTime(dt);
 180         c.add(Calendar.DATE, 1);
 181         dataObj.expires = c.getTime();
 182
 183         retVal1.value.add(dataObj);
 184         Mockito.doReturn(true).when(retVal1).isOKhasData();
 185         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 186
 187         DefaultOrg org = Mockito.mock(DefaultOrg.class);
 188         when(trans.org()).thenReturn(org);
 189
 190         PermLookup cassExecutorObj = PermLookup.get(trans, q,"");
 191         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 192
 193         //System.out.println(userRoles.status);
 194         assertEquals("Success",userRoles.details);
 195         Result<List<UserRoleDAO.Data>> userRoles1 = cassExecutorObj.getUserRoles();
 196
 197         //System.out.println(userRoles1.status);
 198         assertEquals(0, userRoles1.status);
 199     }
 200
 201     @Test
 202     public void testGetRole() {
 203         @SuppressWarnings("unchecked")
 204         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 205         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 206         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 207
 208         dataObj.expires = new Date();
 209
 210         retVal1.value.add(dataObj);
 211         Mockito.doReturn(false).when(retVal1).isOKhasData();
 212         Mockito.doReturn(true).when(retVal1).isOK();
 213         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 214         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 215         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 216
 217         //System.out.println(""+userRoles.status);
 218         assertEquals(4,userRoles.status);
 219     }
 220
 221     @Test
 222     public void testGetRoleFirstIf() {
 223         @SuppressWarnings("unchecked")
 224         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 225         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 226         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 227
 228         dataObj.expires = new Date();
 229         dataObj.ns="";
 230         dataObj.rname="";
 231
 232         retVal1.value.add(dataObj);
 233         Mockito.doReturn(false).when(retVal1).isOKhasData();
 234         Mockito.doReturn(false).when(retVal1).isOK();
 235         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 236         Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 237         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 238         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 239
 240 //        System.out.println(""+userRoles.status);
 241         assertEquals(0,userRoles.status);
 242     }
 243
 244     @Test
 245     public void testGetRoleSecondIf() {
 246         @SuppressWarnings("unchecked")
 247         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 248         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 249         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 250
 251         dataObj.expires = new Date();
 252         dataObj.ns="";
 253         dataObj.rname="";
 254
 255         retVal1.value.add(dataObj);
 256         Mockito.doReturn(false).when(retVal1).isOKhasData();
 257         Mockito.doReturn(true).when(retVal1).isOK();
 258         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 259         Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 260         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 261         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 262         userRoles = cassExecutorObj.getRoles();
 263
 264 //        System.out.println(""+userRoles.status);
 265         assertEquals(0,userRoles.status);
 266     }
 267     @Test
 268     public void testGetPerms() {
 269         @SuppressWarnings("unchecked")
 270         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 271         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 272         Mockito.doReturn(false).when(retVal1).isOKhasData();
 273         Mockito.doReturn(true).when(retVal1).isOK();
 274         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 275         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 276         Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 277         userRoles = cassExecutorObj.getPermNames();
 278
 279         //System.out.println(""+userRoles.status);
 280         assertEquals(0,userRoles.status);
 281     }
 282     @Test
 283     public void testGetPermsRrldOk() {
 284         @SuppressWarnings("unchecked")
 285         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 286         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 287         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 288
 289         dataObj.expires = new Date();
 290
 291         retVal1.value.add(dataObj);
 292         Mockito.doReturn(false).when(retVal1).isOKhasData();
 293         Mockito.doReturn(true).when(retVal1).isOK();
 294         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 295         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 296         Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 297
 298         //System.out.println(""+userRoles.status);
 299         assertEquals(4,userRoles.status);
 300     }
 301
 302
 303     @SuppressWarnings("unchecked")
 304     @Test
 305     public void testGetPerm() {
 306         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 307         Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 308
 309         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 310         retVal2.value = new ArrayList<RoleDAO.Data>();
 311         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 312
 313         Date dt = new Date();
 314         Calendar c = Calendar.getInstance();
 315         c.setTime(dt);
 316         c.add(Calendar.DATE, 1);
 317         dataObj.expires = c.getTime();
 318         dataObj.ns = "";
 319         dataObj.rname="";
 320
 321         RoleDAO.Data dataObj1 = Mockito.mock( RoleDAO.Data.class);
 322         Set<String> permSet = new HashSet<String>();
 323         permSet.add("test");
 324         Mockito.doReturn(permSet).when(dataObj1).perms(false);
 325
 326         dt = new Date();
 327         c = Calendar.getInstance();
 328         c.setTime(dt);
 329         c.add(Calendar.DATE, 1);
 330         dataObj1.ns = "test";
 331         dataObj1.perms = permSet;
 332
 333         retVal1.value.add(dataObj);
 334         retVal2.value.add(dataObj1);
 335         Mockito.doReturn(true).when(retVal1).isOKhasData();
 336         Mockito.doReturn(true).when(retVal1).isOK();
 337         Mockito.doReturn(true).when(retVal2).isOK();
 338         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 339         Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 340
 341
 342         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 343 //
 344 //        Mockito.doReturn(retVal2).when(cassExecutorObj).getPermNames();
 345         Result<List<Data>> userRoles = cassExecutorObj.getPerms(true);
 346 //        userRoles = cassExecutorObj.getPerms(false);
 347
 348 //        System.out.println(""+userRoles.status);
 349         assertEquals(0,userRoles.status);
 350     }
 351
 352     @SuppressWarnings("unchecked")
 353     @Test
 354     public void testGetPermFalse() {
 355         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 356         Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 357
 358         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 359         retVal2.value = new ArrayList<RoleDAO.Data>();
 360         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 361
 362         Date dt = new Date();
 363         Calendar c = Calendar.getInstance();
 364         c.setTime(dt);
 365         c.add(Calendar.DATE, 1);
 366         dataObj.expires = c.getTime();
 367         dataObj.ns = "";
 368         dataObj.rname="";
 369
 370         RoleDAO.Data dataObj1 = Mockito.mock( RoleDAO.Data.class);
 371         Set<String> permSet = new HashSet<String>();
 372         permSet.add("test");
 373         Mockito.doReturn(permSet).when(dataObj1).perms(false);
 374
 375         dt = new Date();
 376         c = Calendar.getInstance();
 377         c.setTime(dt);
 378         c.add(Calendar.DATE, 1);
 379         dataObj1.ns = "test";
 380         dataObj1.perms = permSet;
 381
 382         retVal1.value.add(dataObj);
 383         retVal2.value.add(dataObj1);
 384         Mockito.doReturn(true).when(retVal1).isOKhasData();
 385         Mockito.doReturn(true).when(retVal1).isOK();
 386         Mockito.doReturn(true).when(retVal2).isOK();
 387         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 388         Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 389
 390
 391         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 392 //
 393 //        Mockito.doReturn(retVal2).when(cassExecutorObj).getPermNames();
 394         Result<List<Data>> userRoles = cassExecutorObj.getPerms(false);
 395         userRoles = cassExecutorObj.getPerms(false);
 396
 397 //        System.out.println(""+userRoles.status);
 398         assertEquals(0,userRoles.status);
 399     }
 400
 401 }