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 }