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