auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.java

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