auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.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
  22 package org.onap.aaf.auth.dao.cass;
  23
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.MockitoAnnotations.initMocks;
  26
  27 import java.io.ByteArrayInputStream;
  28 import java.io.ByteArrayOutputStream;
  29 import java.io.DataInputStream;
  30 import java.io.DataOutputStream;
  31 import java.io.IOException;
  32 import java.lang.reflect.Constructor;
  33 import java.lang.reflect.Field;
  34 import java.lang.reflect.InvocationTargetException;
  35 import java.lang.reflect.Method;
  36 import java.nio.ByteBuffer;
  37 import java.util.HashSet;
  38 import java.util.List;
  39 import java.util.TreeSet;
  40
  41 import org.junit.Before;
  42 import org.junit.Test;
  43 import org.mockito.Mock;
  44 import org.mockito.Mockito;
  45 import org.onap.aaf.auth.dao.AbsCassDAO;
  46 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
  47 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
  48 import org.onap.aaf.auth.dao.CassAccess;
  49 import org.onap.aaf.auth.dao.CassDAOImpl;
  50 import org.onap.aaf.auth.dao.cass.RoleDAO.Data;
  51 import org.onap.aaf.auth.dao.hl.Question;
  52 import org.onap.aaf.auth.env.AuthzTrans;
  53 import org.onap.aaf.auth.layer.Result;
  54 import org.onap.aaf.cadi.config.Config;
  55 import org.onap.aaf.misc.env.APIException;
  56 import org.onap.aaf.misc.env.Env;
  57 import org.onap.aaf.misc.env.LogTarget;
  58 import org.onap.aaf.misc.env.TimeTaken;
  59
  60 import com.datastax.driver.core.Cluster;
  61 import com.datastax.driver.core.ResultSet;
  62 import com.datastax.driver.core.Row;
  63 import com.datastax.driver.core.Session;
  64
  65 public class JU_RoleDAO {
  66
  67     @Mock
  68     AuthzTrans trans;
  69     @Mock
  70     Cluster cluster;
  71     @Mock
  72     Session session;
  73
  74     @Before
  75     public void setUp() throws APIException, IOException {
  76         initMocks(this);
  77         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn();
  78         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
  79         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
  80         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
  81         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init();
  82         Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE);
  83         Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE);
  84         Mockito.doReturn(session).when(cluster).connect("test");
  85     }
  86
  87     @Test
  88     public void testInit() {
  89         TimeTaken tt = Mockito.mock(TimeTaken.class);
  90         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
  91         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
  92         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
  93         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
  94         try {
  95             new RoleDAO(trans, cluster, "test");
  96         } catch (APIException | IOException e) {
  97             // TODO Auto-generated catch block
  98             e.printStackTrace();
  99         }
 100 //        daoObj.
 101     }
 102     @Test
 103     public void testReadByStartAndTarget() {
 104         TimeTaken tt = Mockito.mock(TimeTaken.class);
 105         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 106         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 107         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 108         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 109         RoleDAO daoObj = null;
 110         try {
 111             daoObj = new RoleDAO(trans, cluster, "test");
 112         } catch (APIException | IOException e) {
 113             // TODO Auto-generated catch block
 114             e.printStackTrace();
 115         }
 116
 117         PSInfo psObj = Mockito.mock(PSInfo.class);
 118         setPsByStartAndTarget(daoObj, psObj, "psName");
 119
 120         Result<List<RoleDAO.Data>>  rs1 = new Result<List<RoleDAO.Data>>(null,0,"test",new Object[0]);
 121         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAO READ", new Object[]{"test"});
 122
 123         daoObj.readName(trans, "test");
 124     }
 125     @Test
 126     public void testReadChildren() {
 127         TimeTaken tt = Mockito.mock(TimeTaken.class);
 128         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 129         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 130         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 131         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 132         RoleDAO daoObj = null;
 133         try {
 134             daoObj = new RoleDAO(trans, cluster, "test");
 135         } catch (APIException | IOException e) {
 136             // TODO Auto-generated catch block
 137             e.printStackTrace();
 138         }
 139
 140         PSInfo psObj = Mockito.mock(PSInfo.class);
 141         setPsByStartAndTarget(daoObj, psObj, "psChildren");
 142
 143         Result<List<RoleDAO.Data>>  rs1 = new Result<List<RoleDAO.Data>>(null,0,"test",new Object[0]);
 144         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAO READ", new Object[]{"test"});
 145
 146         daoObj.readChildren(trans, "test", "test");
 147
 148         daoObj.readChildren(trans, "test", "*");
 149         daoObj.readChildren(trans, "test", "");
 150     }
 151     @Test
 152     public void testReadNs() {
 153         TimeTaken tt = Mockito.mock(TimeTaken.class);
 154         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 155         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 156         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 157         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 158         RoleDAO daoObj = null;
 159         try {
 160             daoObj = new RoleDAO(trans, cluster, "test");
 161         } catch (APIException | IOException e) {
 162             // TODO Auto-generated catch block
 163             e.printStackTrace();
 164         }
 165
 166         PSInfo psObj = Mockito.mock(PSInfo.class);
 167         setPsByStartAndTarget(daoObj, psObj, "psNS");
 168
 169         Result<List<RoleDAO.Data>>  rs1 = new Result<List<RoleDAO.Data>>(null,0,"test",new Object[0]);
 170         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAO READ", new Object[]{"test"});
 171
 172         daoObj.readNS(trans, "test");
 173     }
 174     @Test
 175     public void testAddRole() {
 176         PSInfo psObj = Mockito.mock(PSInfo.class);
 177         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 178         RoleDAO.Data data = new RoleDAO.Data();
 179         CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 180         RoleDAOImpl daoObj=null;
 181         try {
 182             daoObj = new RoleDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, Mockito.mock(Session.class));
 183         } catch (APIException | IOException e) {
 184             // TODO Auto-generated catch block
 185             e.printStackTrace();
 186         }
 187
 188         TimeTaken tt = Mockito.mock(TimeTaken.class);
 189         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 190         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 191         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 192         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 193
 194         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 195         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 196         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 197         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 198
 199         Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 200         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl CREATE", data);
 201         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl UPDATE", data);
 202         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAOImpl READ", data);
 203         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl DELETE", data);
 204         Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 205
 206         Result<Void> rs2 = new Result<Void>(null,0,"test",new Object[0]);
 207         Mockito.doReturn(rs2).when(cacheInfoDAO).touch(Mockito.any(AuthzTrans.class),Mockito.anyString(), Mockito.anyVararg());
 208
 209          rs1 = new Result<List<Data>>(null,1,"test",new Object[0]);
 210         Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 211         Mockito.doReturn("test user").when(trans).user();
 212         Field cbField;
 213         try {
 214             cbField = CassAccess.class.getDeclaredField("cb");
 215             cbField.setAccessible(true);
 216             cbField.set(daoObj, null);
 217         } catch (NoSuchFieldException | SecurityException e) {
 218             // TODO Auto-generated catch block
 219             e.printStackTrace();
 220         } catch (IllegalArgumentException e) {
 221             // TODO Auto-generated catch block
 222             e.printStackTrace();
 223         } catch (IllegalAccessException e) {
 224             // TODO Auto-generated catch block
 225             e.printStackTrace();
 226         }
 227
 228         PermDAO.Data perm = new PermDAO.Data();
 229         RoleDAO.Data role = new RoleDAO.Data();
 230         Result<Void> retVal = daoObj.addPerm(trans, role, perm);
 231         assertTrue(retVal.status == 9);
 232
 233         Field owningField;
 234         try {
 235             owningField = AbsCassDAO.class.getDeclaredField("owningDAO");
 236             owningField.setAccessible(true);
 237             owningField.set(daoObj, null);
 238         } catch (NoSuchFieldException | SecurityException e) {
 239             // TODO Auto-generated catch block
 240             e.printStackTrace();
 241         } catch (IllegalArgumentException e) {
 242             // TODO Auto-generated catch block
 243             e.printStackTrace();
 244         } catch (IllegalAccessException e) {
 245             // TODO Auto-generated catch block
 246             e.printStackTrace();
 247         }
 248         retVal = daoObj.addPerm(trans, role, perm);
 249         assertTrue(retVal.status == 0);
 250     }
 251
 252     @Test
 253     public void testDelRole() {
 254         PSInfo psObj = Mockito.mock(PSInfo.class);
 255         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 256         RoleDAO.Data data = new RoleDAO.Data();
 257         CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 258         RoleDAOImpl daoObj=null;
 259         try {
 260             daoObj = new RoleDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, Mockito.mock(Session.class));
 261         } catch (APIException | IOException e) {
 262             // TODO Auto-generated catch block
 263             e.printStackTrace();
 264         }
 265
 266         TimeTaken tt = Mockito.mock(TimeTaken.class);
 267         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 268         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 269         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 270         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 271
 272         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 273         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 274         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 275         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 276
 277         Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 278         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl CREATE", data);
 279         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl UPDATE", data);
 280         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAOImpl READ", data);
 281         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl DELETE", data);
 282         Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 283
 284         Result<Void> rs2 = new Result<Void>(null,0,"test",new String[0]);
 285         Mockito.doReturn(rs2).when(cacheInfoDAO).touch(Mockito.any(AuthzTrans.class),Mockito.anyString(), Mockito.anyVararg());
 286
 287          rs1 = new Result<List<Data>>(null,1,"test",new String[0]);
 288         Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 289         Mockito.doReturn("test user").when(trans).user();
 290
 291         PermDAO.Data perm = new PermDAO.Data();
 292         Field cbField;
 293         try {
 294             cbField = CassAccess.class.getDeclaredField("cb");
 295             cbField.setAccessible(true);
 296             cbField.set(daoObj, null);
 297         } catch (NoSuchFieldException | SecurityException e) {
 298             // TODO Auto-generated catch block
 299             e.printStackTrace();
 300         } catch (IllegalArgumentException e) {
 301             // TODO Auto-generated catch block
 302             e.printStackTrace();
 303         } catch (IllegalAccessException e) {
 304             // TODO Auto-generated catch block
 305             e.printStackTrace();
 306         }
 307         RoleDAO.Data role = new RoleDAO.Data();
 308         Result<Void> retVal = daoObj.delPerm(trans, role, perm);
 309         assertTrue(retVal.status == 9);
 310
 311         Field owningDaoField;
 312         try {
 313             owningDaoField = AbsCassDAO.class.getDeclaredField("owningDAO");
 314             owningDaoField.setAccessible(true);
 315             owningDaoField.set(daoObj, null);
 316         } catch (NoSuchFieldException | SecurityException e) {
 317             // TODO Auto-generated catch block
 318             e.printStackTrace();
 319         } catch (IllegalArgumentException e) {
 320             // TODO Auto-generated catch block
 321             e.printStackTrace();
 322         } catch (IllegalAccessException e) {
 323             // TODO Auto-generated catch block
 324             e.printStackTrace();
 325         }
 326         retVal = daoObj.delPerm(trans,role, perm);
 327         assertTrue(retVal.status == 0);
 328     }
 329
 330     @Test
 331     public void testAddDescription() {
 332         PSInfo psObj = Mockito.mock(PSInfo.class);
 333         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 334         RoleDAO.Data data = new RoleDAO.Data();
 335         CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 336         RoleDAOImpl daoObj=null;
 337         try {
 338             daoObj = new RoleDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, Mockito.mock(Session.class));
 339         } catch (APIException | IOException e) {
 340             // TODO Auto-generated catch block
 341             e.printStackTrace();
 342         }
 343
 344         TimeTaken tt = Mockito.mock(TimeTaken.class);
 345         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 346         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 347         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 348         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 349
 350         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 351         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 352         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 353         Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 354
 355         Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new String[0]);
 356         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl CREATE", data);
 357         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl UPDATE", data);
 358         Mockito.doReturn(rs1).when(psObj).read(trans, "RoleDAOImpl READ", data);
 359         Mockito.doReturn(rs1).when(psObj).exec(trans, "RoleDAOImpl DELETE", data);
 360         Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 361
 362         Result<Void> rs2 = new Result<Void>(null,1,"test",new String[0]);
 363         Mockito.doReturn(rs2).when(cacheInfoDAO).touch(Mockito.any(AuthzTrans.class),Mockito.anyString(), Mockito.anyVararg());
 364
 365          rs1 = new Result<List<Data>>(null,1,"test",new String[0]);
 366         Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 367         Mockito.doReturn("test user").when(trans).user();
 368
 369         RoleDAO.Data perm = new RoleDAO.Data();
 370         Field cbField;
 371         try {
 372             cbField = CassAccess.class.getDeclaredField("cb");
 373             cbField.setAccessible(true);
 374             cbField.set(daoObj, null);
 375         } catch (NoSuchFieldException | SecurityException e) {
 376             // TODO Auto-generated catch block
 377             e.printStackTrace();
 378         } catch (IllegalArgumentException e) {
 379             // TODO Auto-generated catch block
 380             e.printStackTrace();
 381         } catch (IllegalAccessException e) {
 382             // TODO Auto-generated catch block
 383             e.printStackTrace();
 384         }
 385
 386         Result<Void> retVal = daoObj.addDescription(trans, "test", "test", "test");
 387         assertTrue(retVal.status == 9);
 388
 389         Field owningDaoField;
 390         try {
 391             owningDaoField = AbsCassDAO.class.getDeclaredField("owningDAO");
 392             owningDaoField.setAccessible(true);
 393             owningDaoField.set(daoObj, null);
 394         } catch (NoSuchFieldException | SecurityException e) {
 395             // TODO Auto-generated catch block
 396             e.printStackTrace();
 397         } catch (IllegalArgumentException e) {
 398             // TODO Auto-generated catch block
 399             e.printStackTrace();
 400         } catch (IllegalAccessException e) {
 401             // TODO Auto-generated catch block
 402             e.printStackTrace();
 403         }
 404         retVal = daoObj.addDescription(trans, "test", "test", "test");
 405         assertTrue(retVal.status == 0);
 406     }
 407
 408     public void setPsByStartAndTarget(RoleDAO RoleDAOObj, PSInfo psInfoObj, String fieldName) {
 409         Field RoleDAOField;
 410         try {
 411             RoleDAOField = RoleDAO.class.getDeclaredField(fieldName);
 412
 413             RoleDAOField.setAccessible(true);
 414             // remove final modifier from field
 415             Field modifiersField = Field.class.getDeclaredField("modifiers");
 416             modifiersField.setAccessible(true);
 417 //            modifiersField.setInt(RoleDAOField, RoleDAOField.getModifiers() & ~Modifier.FINAL);
 418
 419             RoleDAOField.set(RoleDAOObj, psInfoObj);
 420         } catch (NoSuchFieldException | SecurityException e) {
 421             // TODO Auto-generated catch block
 422             e.printStackTrace();
 423         } catch (IllegalArgumentException e) {
 424             // TODO Auto-generated catch block
 425             e.printStackTrace();
 426         } catch (IllegalAccessException e) {
 427             // TODO Auto-generated catch block
 428             e.printStackTrace();
 429         }
 430     }
 431
 432     @Test
 433     public void testWasModified() {
 434         TimeTaken tt = Mockito.mock(TimeTaken.class);
 435         Mockito.doReturn(tt).when(trans).start("RoleDAO CREATE", Env.REMOTE);
 436         Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 437         Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 438         Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on RoleDAO", Env.SUB);
 439         Mockito.doReturn(tt).when(trans).start("DELETE Future",Env.REMOTE);
 440         Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 441         Mockito.doNothing().when(tt).done();
 442         RoleDAO.Data data  = new RoleDAO.Data();
 443         PSInfo createPS = Mockito.mock(PSInfo.class);
 444
 445         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 446         Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new String[0]);
 447         Result<Void> rs2 = new Result<Void>(null,0,"test",new String[0]);
 448         Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 449
 450         CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 451         Mockito.doReturn(rs2).when(cacheInfoDAO).touch(Mockito.any(AuthzTrans.class),Mockito.anyString(), Mockito.anyVararg());
 452
 453         RoleDAOImpl daoObj = null;
 454         try {
 455             daoObj = new RoleDAOImpl(trans, historyDAO, cacheInfoDAO, createPS );
 456         } catch (APIException | IOException e) {
 457             // TODO Auto-generated catch block
 458             e.printStackTrace();
 459         }
 460         daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"});
 461
 462         daoObj.wasModified(trans, CRUD.create, data, new String[] {});
 463         daoObj.wasModified(trans, CRUD.create, data, new String[] {null});
 464         daoObj.wasModified(trans, CRUD.create, data, new String[] {"test",null});
 465         daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"});
 466
 467         rs1 = new Result<ResultSet>(null,1,"test",new String[0]);
 468         Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 469         daoObj.wasModified(trans, CRUD.delete, data, new String[] {"test","test"});
 470     }
 471
 472     @Test
 473     public void testSecondConstructor() {
 474         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 475         CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 476
 477         RoleDAO daoObj = new RoleDAO(trans, historyDAO, cacheInfoDAO);
 478
 479     }
 480
 481     @Test
 482     public void testFutureLoader(){
 483         Class<?> innerClass = null;
 484         Class<?>[] innerClassArr = RoleDAO.class.getDeclaredClasses();
 485         for(Class indCls:innerClassArr) {
 486             if(indCls.getName().contains("RoleLoader")) {
 487                 innerClass = indCls;
 488                 break;
 489             }
 490         }
 491
 492         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 493         constructor.setAccessible(true);
 494
 495         try {
 496
 497             Object obj = constructor.newInstance(1);
 498             Method innnerClassMtd;
 499
 500             RoleDAO.Data data  = new RoleDAO.Data();
 501             Row row = Mockito.mock(Row.class);
 502             ByteBuffer bbObj = ByteBuffer.allocateDirect(10);
 503             bbObj.limit(7);
 504             bbObj.put(0, new Byte("0"));
 505             bbObj.put(1, new Byte("1"));
 506             bbObj.put(2, new Byte("2"));
 507             Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1);
 508
 509             innnerClassMtd = innerClass.getMethod("load", new Class[] {RoleDAO.Data.class, Row.class});
 510             innnerClassMtd.invoke(obj, new Object[] {data, row});
 511
 512             innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {RoleDAO.Data.class, Integer.TYPE, Object[].class });
 513             innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test"} });
 514 //
 515             innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {RoleDAO.Data.class, Integer.TYPE, Object[].class });
 516             innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 517
 518             ByteArrayOutputStream baos = new ByteArrayOutputStream();
 519             DataOutputStream dos = new DataOutputStream(baos);
 520             innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {RoleDAO.Data.class, DataOutputStream.class });
 521             innnerClassMtd.invoke(obj, new Object[] {data, dos });
 522
 523             ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 524             DataInputStream dis = new DataInputStream(bais);
 525             innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {RoleDAO.Data.class, DataInputStream.class });
 526             innnerClassMtd.invoke(obj, new Object[] {data, dis });
 527
 528         } catch (InstantiationException e) {
 529             // TODO Auto-generated catch block
 530             e.printStackTrace();
 531         } catch (IllegalAccessException e) {
 532             // TODO Auto-generated catch block
 533             e.printStackTrace();
 534         } catch (IllegalArgumentException e) {
 535             // TODO Auto-generated catch block
 536             e.printStackTrace();
 537         } catch (InvocationTargetException e) {
 538             // TODO Auto-generated catch block
 539             e.printStackTrace();
 540         } catch (NoSuchMethodException e) {
 541             // TODO Auto-generated catch block
 542             e.printStackTrace();
 543         } catch (SecurityException e) {
 544             // TODO Auto-generated catch block
 545             e.printStackTrace();
 546         }
 547     }
 548
 549     @Test
 550     public void testData() {
 551         RoleDAO.Data data = new RoleDAO.Data();
 552         NsSplit nss = new NsSplit("test", "test");
 553         data = new RoleDAO.Data();
 554
 555         data.toString();
 556
 557
 558         Question q = Mockito.mock( Question.class);
 559
 560         Result<NsSplit> rs = new Result<NsSplit>(nss,0,"test",new Object[0]);
 561         Mockito.doReturn(rs).when(q).deriveNsSplit(trans, "test");
 562         Result<Data> retVal= RoleDAO.Data.decode(trans, q, "test|||");
 563         assertTrue(retVal.status==0);
 564         Result<String[]> retVal1= RoleDAO.Data.decodeToArray(trans, q, "test|||");
 565         assertTrue(retVal.status==0);
 566         retVal= RoleDAO.Data.decode(trans, q, "test");
 567         retVal1= RoleDAO.Data.decodeToArray(trans, q, "test");
 568         assertTrue(retVal.status==0);
 569
 570         rs = new Result<NsSplit>(nss,1,"test",new Object[0]);
 571         Mockito.doReturn(rs).when(q).deriveNsSplit(trans, "test");
 572         retVal= RoleDAO.Data.decode(trans, q, "test");
 573         retVal1= RoleDAO.Data.decodeToArray(trans, q, "test");
 574         assertTrue(retVal.status==1);
 575
 576         retVal= RoleDAO.Data.decode(trans, q, "test");
 577         retVal1= RoleDAO.Data.decodeToArray(trans, q, "test");
 578         assertTrue(retVal.status==1);
 579
 580         NsDAO.Data ns = new NsDAO.Data();
 581         ns.name="test";
 582         RoleDAO.Data.create(ns, "test");
 583
 584         UserRoleDAO.Data urdd = new UserRoleDAO.Data();
 585         urdd.ns="test";
 586         RoleDAO.Data dd=RoleDAO.Data.decode(urdd);
 587         assertTrue("test".equals(dd.ns));
 588
 589         assertTrue(data.encode().contains("null"));
 590
 591         data.perms = null;
 592         data.perms(true);
 593
 594         data.perms = new HashSet<>();
 595         data.perms(true);
 596
 597         data.perms(false);
 598         data.perms = new TreeSet<>();
 599         data.perms(true);
 600     }
 601
 602 }
 603
 604 class RoleDAOImpl extends RoleDAO{
 605     public RoleDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,CacheInfoDAO cacheDao, PSInfo readPS) throws APIException, IOException {
 606         super(trans, historyDAO, cacheDao);
 607         setPs(this, readPS, "createPS");
 608     }
 609
 610     public RoleDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,CacheInfoDAO cacheDao, PSInfo readPS, Session session  ) throws APIException, IOException {
 611         super(trans, historyDAO, cacheDao);
 612         setPs(this, readPS, "createPS");
 613         setSession(this, session);
 614     }
 615
 616
 617     public void setPs(RoleDAOImpl RoleDAOObj, PSInfo psInfoObj, String methodName) {
 618         Field RoleDAOField;
 619         try {
 620             RoleDAOField = CassDAOImpl.class.getDeclaredField(methodName);
 621
 622             RoleDAOField.setAccessible(true);
 623             // remove final modifier from field
 624             Field modifiersField = Field.class.getDeclaredField("modifiers");
 625             modifiersField.setAccessible(true);
 626 //            modifiersField.setInt(RoleDAOField, RoleDAOField.getModifiers() & ~Modifier.FINAL);
 627
 628             RoleDAOField.set(RoleDAOObj, psInfoObj);
 629         } catch (NoSuchFieldException | SecurityException e) {
 630             // TODO Auto-generated catch block
 631             e.printStackTrace();
 632         } catch (IllegalArgumentException e) {
 633             // TODO Auto-generated catch block
 634             e.printStackTrace();
 635         } catch (IllegalAccessException e) {
 636             // TODO Auto-generated catch block
 637             e.printStackTrace();
 638         }
 639     }
 640
 641     public void setSession(RoleDAOImpl approvalDaoObj, Session session) {
 642         Field nsDaoField;
 643         try {
 644             nsDaoField = AbsCassDAO.class.getDeclaredField("session");
 645
 646             nsDaoField.setAccessible(true);
 647             // remove final modifier from field
 648             Field modifiersField = Field.class.getDeclaredField("modifiers");
 649             modifiersField.setAccessible(true);
 650 //            modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 651
 652             nsDaoField.set(approvalDaoObj, session);
 653         } catch (NoSuchFieldException | SecurityException e) {
 654             // TODO Auto-generated catch block
 655             e.printStackTrace();
 656         } catch (IllegalArgumentException e) {
 657             // TODO Auto-generated catch block
 658             e.printStackTrace();
 659         } catch (IllegalAccessException e) {
 660             // TODO Auto-generated catch block
 661             e.printStackTrace();
 662         }
 663     }
 664
 665 }