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
  53
  54 @RunWith(MockitoJUnitRunner.class)
  55 public class JU_PermLookup {
  56
  57
  58
  59     @Mock
  60     AuthzTrans trans;
  61
  62     @Mock
  63     Question q;
  64
  65     @Mock
  66     Access access;
  67
  68     @Mock
  69     CachedRoleDAO roleDAO;
  70
  71     @Mock
  72     CachedUserRoleDAO userRoleDAO;
  73
  74     Function f;
  75
  76     @Before
  77     public void setUp() throws Exception {
  78         initMocks(this);
  79         Mockito.doReturn(userRoleDAO).when(q).userRoleDAO();
  80         Mockito.doReturn(roleDAO).when(q).roleDAO();
  81
  82         try {
  83             Mockito.doReturn("0.0").when(access).getProperty("aaf_root_ns","org.osaaf.aaf");
  84             Mockito.doReturn(new Properties()).when(access).getProperties();
  85             Define.set(access);
  86
  87             when(trans.error()).thenReturn(new LogTarget() {
  88
  89                 @Override
  90                 public void printf(String fmt, Object... vars) {}
  91
  92                 @Override
  93                 public void log(Throwable e, Object... msgs) {
  94                     e.getMessage();
  95                     e.printStackTrace();
  96                     msgs.toString();
  97
  98                 }
  99
 100                 @Override
 101                 public void log(Object... msgs) {
 102                 }
 103
 104                 @Override
 105                 public boolean isLoggable() {
 106
 107                     return true;
 108                 }
 109             });
 110         } catch (CadiException e) {
 111             // TODO Auto-generated catch block
 112             e.printStackTrace();
 113         }
 114         f =new Function(trans, q);
 115     }
 116
 117
 118 //    @Test
 119 //    public void testPerm() {
 120 //
 121 //        PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 122 //
 123 ////        System.out.println(cassExecutorObj);
 124 ////        assertFalse(retVal);
 125 //    }
 126
 127     @Test
 128     public void testGetUserRole() {
 129         @SuppressWarnings("unchecked")
 130         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 131         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 132         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 133
 134         dataObj.expires = new Date();
 135
 136         retVal1.value.add(dataObj);
 137         Mockito.doReturn(true).when(retVal1).isOKhasData();
 138         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 139         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 140         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 141
 142         //System.out.println(""+userRoles.status);
 143         assertEquals(24,userRoles.status);
 144     }
 145
 146     @Test
 147     public void testGetUserRolesFirstIf() {
 148         @SuppressWarnings("unchecked")
 149         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 150         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 151
 152         Mockito.doReturn(false).when(retVal1).isOKhasData();
 153         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 154         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 155         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 156
 157 //        System.out.println("output is"+userRoles.status);
 158         assertEquals(0,userRoles.status);
 159     }
 160
 161     @Test
 162     public void testGetUserRolesSecondIf() {
 163         @SuppressWarnings("unchecked")
 164         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 165         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 166         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 167
 168         Date dt = new Date();
 169         Calendar c = Calendar.getInstance();
 170         c.setTime(dt);
 171         c.add(Calendar.DATE, 1);
 172         dataObj.expires = c.getTime();
 173
 174         retVal1.value.add(dataObj);
 175         Mockito.doReturn(true).when(retVal1).isOKhasData();
 176         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 177         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 178         Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 179
 180         //System.out.println(userRoles.status);
 181         assertEquals("Success",userRoles.details);
 182         Result<List<UserRoleDAO.Data>> userRoles1 = cassExecutorObj.getUserRoles();
 183
 184         //System.out.println(userRoles1.status);
 185         assertEquals(0, userRoles1.status);
 186     }
 187
 188     @Test
 189     public void testGetRole() {
 190         @SuppressWarnings("unchecked")
 191         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 192         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 193         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 194
 195         dataObj.expires = new Date();
 196
 197         retVal1.value.add(dataObj);
 198         Mockito.doReturn(false).when(retVal1).isOKhasData();
 199         Mockito.doReturn(true).when(retVal1).isOK();
 200         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 201         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 202         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 203
 204         //System.out.println(""+userRoles.status);
 205         assertEquals(4,userRoles.status);
 206     }
 207
 208     @Test
 209     public void testGetRoleFirstIf() {
 210         @SuppressWarnings("unchecked")
 211         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 212         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 213         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 214
 215         dataObj.expires = new Date();
 216         dataObj.ns="";
 217         dataObj.rname="";
 218
 219         retVal1.value.add(dataObj);
 220         Mockito.doReturn(false).when(retVal1).isOKhasData();
 221         Mockito.doReturn(false).when(retVal1).isOK();
 222         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 223         Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 224         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 225         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 226
 227 //        System.out.println(""+userRoles.status);
 228         assertEquals(0,userRoles.status);
 229     }
 230
 231     @Test
 232     public void testGetRoleSecondIf() {
 233         @SuppressWarnings("unchecked")
 234         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 235         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 236         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 237
 238         dataObj.expires = new Date();
 239         dataObj.ns="";
 240         dataObj.rname="";
 241
 242         retVal1.value.add(dataObj);
 243         Mockito.doReturn(false).when(retVal1).isOKhasData();
 244         Mockito.doReturn(true).when(retVal1).isOK();
 245         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 246         Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 247         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 248         Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 249         userRoles = cassExecutorObj.getRoles();
 250
 251 //        System.out.println(""+userRoles.status);
 252         assertEquals(0,userRoles.status);
 253     }
 254     @Test
 255     public void testGetPerms() {
 256         @SuppressWarnings("unchecked")
 257         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 258         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 259         Mockito.doReturn(false).when(retVal1).isOKhasData();
 260         Mockito.doReturn(true).when(retVal1).isOK();
 261         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 262         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 263         Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 264         userRoles = cassExecutorObj.getPermNames();
 265
 266         //System.out.println(""+userRoles.status);
 267         assertEquals(0,userRoles.status);
 268     }
 269     @Test
 270     public void testGetPermsRrldOk() {
 271         @SuppressWarnings("unchecked")
 272         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 273         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 274         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 275
 276         dataObj.expires = new Date();
 277
 278         retVal1.value.add(dataObj);
 279         Mockito.doReturn(false).when(retVal1).isOKhasData();
 280         Mockito.doReturn(true).when(retVal1).isOK();
 281         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 282         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 283         Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 284
 285         //System.out.println(""+userRoles.status);
 286         assertEquals(4,userRoles.status);
 287     }
 288
 289
 290     @SuppressWarnings("unchecked")
 291     @Test
 292     public void testGetPerm() {
 293         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 294         Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 295
 296         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 297         retVal2.value = new ArrayList<RoleDAO.Data>();
 298         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 299
 300         Date dt = new Date();
 301         Calendar c = Calendar.getInstance();
 302         c.setTime(dt);
 303         c.add(Calendar.DATE, 1);
 304         dataObj.expires = c.getTime();
 305         dataObj.ns = "";
 306         dataObj.rname="";
 307
 308         RoleDAO.Data dataObj1 = Mockito.mock( RoleDAO.Data.class);
 309         Set<String> permSet = new HashSet<String>();
 310         permSet.add("test");
 311         Mockito.doReturn(permSet).when(dataObj1).perms(false);
 312
 313         dt = new Date();
 314         c = Calendar.getInstance();
 315         c.setTime(dt);
 316         c.add(Calendar.DATE, 1);
 317         dataObj1.ns = "test";
 318         dataObj1.perms = permSet;
 319
 320         retVal1.value.add(dataObj);
 321         retVal2.value.add(dataObj1);
 322         Mockito.doReturn(true).when(retVal1).isOKhasData();
 323         Mockito.doReturn(true).when(retVal1).isOK();
 324         Mockito.doReturn(true).when(retVal2).isOK();
 325         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 326         Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 327
 328
 329         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 330 //
 331 //        Mockito.doReturn(retVal2).when(cassExecutorObj).getPermNames();
 332         Result<List<Data>> userRoles = cassExecutorObj.getPerms(true);
 333 //        userRoles = cassExecutorObj.getPerms(false);
 334
 335 //        System.out.println(""+userRoles.status);
 336         assertEquals(0,userRoles.status);
 337     }
 338
 339     @SuppressWarnings("unchecked")
 340     @Test
 341     public void testGetPermFalse() {
 342         Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 343         Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 344
 345         retVal1.value = new ArrayList<UserRoleDAO.Data>();
 346         retVal2.value = new ArrayList<RoleDAO.Data>();
 347         UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
 348
 349         Date dt = new Date();
 350         Calendar c = Calendar.getInstance();
 351         c.setTime(dt);
 352         c.add(Calendar.DATE, 1);
 353         dataObj.expires = c.getTime();
 354         dataObj.ns = "";
 355         dataObj.rname="";
 356
 357         RoleDAO.Data dataObj1 = Mockito.mock( RoleDAO.Data.class);
 358         Set<String> permSet = new HashSet<String>();
 359         permSet.add("test");
 360         Mockito.doReturn(permSet).when(dataObj1).perms(false);
 361
 362         dt = new Date();
 363         c = Calendar.getInstance();
 364         c.setTime(dt);
 365         c.add(Calendar.DATE, 1);
 366         dataObj1.ns = "test";
 367         dataObj1.perms = permSet;
 368
 369         retVal1.value.add(dataObj);
 370         retVal2.value.add(dataObj1);
 371         Mockito.doReturn(true).when(retVal1).isOKhasData();
 372         Mockito.doReturn(true).when(retVal1).isOK();
 373         Mockito.doReturn(true).when(retVal2).isOK();
 374         Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 375         Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 376
 377
 378         PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 379 //
 380 //        Mockito.doReturn(retVal2).when(cassExecutorObj).getPermNames();
 381         Result<List<Data>> userRoles = cassExecutorObj.getPerms(false);
 382         userRoles = cassExecutorObj.getPerms(false);
 383
 384 //        System.out.println(""+userRoles.status);
 385         assertEquals(0,userRoles.status);
 386     }
 387
 388 }