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 }