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