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