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

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