auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.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.IOException;
  28 import java.lang.reflect.Constructor;
  29 import java.lang.reflect.Field;
  30 import java.lang.reflect.InvocationTargetException;
  31 import java.lang.reflect.Method;
  32 import java.net.URI;
  33 import java.net.URISyntaxException;
  34 import java.util.ArrayList;
  35 import java.util.List;
  36
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.mockito.Mock;
  40 import org.mockito.Mockito;
  41 import org.onap.aaf.auth.dao.AbsCassDAO;
  42 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
  43 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
  44 import org.onap.aaf.auth.dao.cass.CacheInfoDAO.Data;
  45 import org.onap.aaf.auth.env.AuthzEnv;
  46 import org.onap.aaf.auth.env.AuthzTrans;
  47 import org.onap.aaf.auth.layer.Result;
  48 import org.onap.aaf.cadi.CadiException;
  49 import org.onap.aaf.cadi.SecuritySetter;
  50 import org.onap.aaf.cadi.client.Rcli;
  51 import org.onap.aaf.cadi.config.Config;
  52 import org.onap.aaf.cadi.http.HMangr;
  53 import org.onap.aaf.misc.env.APIException;
  54 import org.onap.aaf.misc.env.Env;
  55 import org.onap.aaf.misc.env.LogTarget;
  56 import org.onap.aaf.misc.env.TimeTaken;
  57
  58 import com.datastax.driver.core.Cluster;
  59 import com.datastax.driver.core.ColumnDefinitions;
  60 import com.datastax.driver.core.PreparedId;
  61 import com.datastax.driver.core.PreparedStatement;
  62 import com.datastax.driver.core.ResultSet;
  63 import com.datastax.driver.core.Row;
  64 import com.datastax.driver.core.Session;
  65 import com.datastax.driver.core.Statement;
  66 import com.datastax.driver.core.exceptions.DriverException;
  67
  68 public class JU_CacheInfoDAO {
  69
  70         @Mock
  71     AuthzTrans trans;
  72         @Mock
  73         Cluster cluster;
  74         @Mock
  75         Session session;
  76         @Mock
  77         AuthzEnv env;
  78         @Mock
  79         LogTarget logTarget;
  80
  81         @Before
  82         public void setUp() throws APIException, IOException {
  83                 initMocks(this);
  84                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn();
  85                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
  86                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
  87                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
  88                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init();
  89                 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE);
  90                 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE);
  91                 Mockito.doReturn(session).when(cluster).connect("test");
  92         }
  93
  94         @Test
  95         public void testInit() {
  96                 TimeTaken tt = Mockito.mock(TimeTaken.class);
  97                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
  98                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
  99                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 100                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 101                 Mockito.doNothing().when(tt).done();
 102                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 103                 PSInfo createPS = Mockito.mock(PSInfo.class);
 104                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 105                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data);
 106
 107                 CacheInfoDAOImpl daoObj=null;
 108                 try {
 109                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 110                 } catch (APIException | IOException e) {
 111                         // TODO Auto-generated catch block
 112                         e.printStackTrace();
 113                 }
 114 //              data.id
 115                 Result<Data> retVal = daoObj.create(trans, data);
 116                 assertTrue(retVal.status == 0);
 117         }
 118
 119         @Test
 120         public void testTouch() {
 121                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 122                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 123                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test: 1", Env.REMOTE);
 124                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test: 1,2", Env.REMOTE);
 125                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 126                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 127                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 128                 Mockito.doNothing().when(tt).done();
 129
 130                 Mockito.doReturn(logTarget).when(env).debug();
 131
 132                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 133                 PSInfo createPS = Mockito.mock(PSInfo.class);
 134                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 135                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data);
 136
 137                 CacheInfoDAOImpl daoObj=null;
 138                 try {
 139                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 140                 } catch (APIException | IOException e) {
 141                         // TODO Auto-generated catch block
 142                         e.printStackTrace();
 143                 }
 144 //              data.id
 145                 Result<Void> retVal = daoObj.touch(trans, "test", 1, 2);
 146                 assertTrue(retVal.status == 0);
 147                 Mockito.doThrow(DriverException.class).when(session).executeAsync(Mockito.anyString());
 148                 daoObj.startUpdate(env, Mockito.mock(HMangr.class), Mockito.mock(SecuritySetter.class), "12.0.0.1", 8080);
 149                 retVal = daoObj.touch(trans, "test", 1, 2);
 150
 151
 152                 try {
 153                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 154                 } catch (APIException | IOException e) {
 155                         // TODO Auto-generated catch block
 156                         e.printStackTrace();
 157                 }
 158                 assertTrue(retVal.status == Result.ERR_Backend);
 159                 Mockito.doThrow(APIException.class).when(session).executeAsync(Mockito.anyString());
 160                 retVal = daoObj.touch(trans, "test", 1, 2);
 161                 try {
 162                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 163                 } catch (APIException | IOException e) {
 164                         // TODO Auto-generated catch block
 165                         e.printStackTrace();
 166                 }
 167                 assertTrue(retVal.status == Result.ERR_Backend);
 168                 Mockito.doThrow(IOException.class).when(session).executeAsync(Mockito.anyString());
 169                 try {
 170                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 171                 } catch (APIException | IOException e) {
 172                         // TODO Auto-generated catch block
 173                         e.printStackTrace();
 174                 }
 175                 retVal = daoObj.touch(trans, "test", 1, 2);
 176                 assertTrue(retVal.status == Result.ERR_Backend);
 177         }
 178
 179         @Test
 180         public void testCheck() {
 181                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 182                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 183                 Mockito.doReturn(tt).when(trans).start("Check Table Timestamps", Env.REMOTE);
 184                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 185                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 186                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 187                 Mockito.doNothing().when(tt).done();
 188                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 189                 PSInfo createPS = Mockito.mock(PSInfo.class);
 190                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 191                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data);
 192
 193                 CacheInfoDAOImpl daoObj=null;
 194                 PreparedStatement ps = Mockito.mock(PreparedStatement.class);
 195                 Mockito.doReturn(ps).when(session).prepare(Mockito.anyString());
 196                 Mockito.doReturn(Mockito.mock(ColumnDefinitions.class)).when(ps).getVariables();
 197                 Mockito.doReturn(Mockito.mock(PreparedId.class)).when(ps).getPreparedId();
 198                 try {
 199                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 200                 } catch (APIException | IOException e) {
 201                         // TODO Auto-generated catch block
 202                         e.printStackTrace();
 203                 }
 204 //              data.id
 205                 ResultSet resultSet = Mockito.mock(ResultSet.class);
 206                 List<Row> rowList = new ArrayList<>();
 207                 Mockito.doReturn(rowList).when(resultSet).all();
 208                 Mockito.doReturn(resultSet).when(session).execute(Mockito.any(Statement.class));
 209                 Result<Void> retVal = daoObj.check(trans);
 210                 assertTrue(retVal.status == 0);
 211
 212                 Row row  = Mockito.mock(Row.class);
 213                 Mockito.doReturn("test").when(row).getString(Mockito.anyInt());
 214                 rowList.add(row);
 215                 row  = Mockito.mock(Row.class);
 216                 Mockito.doReturn("test").when(row).getString(Mockito.anyInt());
 217                 Mockito.doReturn(100).when(row).getInt(Mockito.anyInt());
 218                 rowList.add(row);
 219                 retVal = daoObj.check(trans);
 220                 assertTrue(retVal.status == 0);
 221
 222                 Mockito.doThrow(DriverException.class).when(session).execute(Mockito.any(Statement.class));
 223                 retVal = daoObj.check(trans);
 224                 assertTrue(retVal.status == Result.ERR_Backend);
 225                 try {
 226                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 227                 } catch (APIException | IOException e) {
 228                         // TODO Auto-generated catch block
 229                         e.printStackTrace();
 230                 }
 231                 Mockito.doThrow(APIException.class).when(session).execute(Mockito.any(Statement.class));
 232                 retVal = daoObj.check(trans);
 233                 assertTrue(retVal.status == Result.ERR_Backend);
 234                 try {
 235                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 236                 } catch (APIException | IOException e) {
 237                         // TODO Auto-generated catch block
 238                         e.printStackTrace();
 239                 }
 240                 Mockito.doThrow(IOException.class).when(session).execute(Mockito.any(Statement.class));
 241                 retVal = daoObj.check(trans);
 242                 assertTrue(retVal.status == Result.ERR_Backend);
 243         }
 244         @Test
 245         public void testStopUpdate() {
 246
 247                 CacheInfoDAO.stopUpdate();
 248
 249         }
 250
 251
 252 /*
 253  *      This has intermittent Null Pointers, JUnit only
 254         @Test
 255         public void testGet() {
 256                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 257                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 258                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test1: 1011", Env.REMOTE);
 259                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 260                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 261                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 262                 Mockito.doNothing().when(tt).done();
 263                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 264                 PSInfo createPS = Mockito.mock(PSInfo.class);
 265                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 266                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data);
 267
 268                 CacheInfoDAOImpl daoObj=null;
 269                 try {
 270                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS);
 271                         Date retVal = daoObj.get(trans, "test", 1011);
 272 //                      assertTrue(retVal.status == 0);
 273                         retVal = daoObj.get(trans, "test1", 1011);
 274                 } catch (APIException | IOException e) {
 275                         e.printStackTrace();
 276                 }
 277         }
 278 */
 279
 280         @Test
 281         public void testWasMOdified() {
 282                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 283                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 284                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 285                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 286                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 287                 Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE);
 288                 Mockito.doNothing().when(tt).done();
 289                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data("test",1);
 290                 PSInfo createPS = Mockito.mock(PSInfo.class);
 291
 292                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 293                 Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new String[0]);
 294                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 295
 296                 CacheInfoDAOImpl daoObj=null;
 297                 try {
 298                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test", createPS);
 299                 } catch (APIException | IOException e) {
 300                         // TODO Auto-generated catch block
 301                         e.printStackTrace();
 302                 }
 303                 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"});
 304
 305
 306         }
 307
 308         @Test
 309         public void testInfoLoader(){
 310                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 311                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 312                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test1: 1011", Env.REMOTE);
 313                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 314                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 315                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 316                 Mockito.doNothing().when(tt).done();
 317                 CacheInfoDAO.Data data1  = new CacheInfoDAO.Data();
 318                 PSInfo createPS = Mockito.mock(PSInfo.class);
 319                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 320                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data1);
 321
 322                 CacheInfoDAOImpl daoObj=null;
 323                 try {
 324                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test", createPS);
 325                 } catch (APIException | IOException e) {
 326                         // TODO Auto-generated catch block
 327                         e.printStackTrace();
 328                 }
 329                 Class[] classList = CacheInfoDAO.class.getDeclaredClasses();
 330                 Class<?> innerClass = null;
 331                 for(Class indCls:classList) {
 332                         if(indCls.getName().contains("InfoLoader")) {
 333                                 innerClass = indCls;
 334                         }
 335                 }
 336         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 337         constructor.setAccessible(true);
 338         try {
 339                         Object obj = constructor.newInstance(1);
 340                         Method innnerClassMtd;
 341
 342                         CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 343                         Row row = Mockito.mock(Row.class);
 344                         innnerClassMtd = innerClass.getMethod("load", new Class[] {CacheInfoDAO.Data.class, Row.class});
 345                         innnerClassMtd.invoke(obj, new Object[] {data, row});
 346
 347                         innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {CacheInfoDAO.Data.class, Integer.TYPE, Object[].class });
 348                         innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"}});
 349
 350                         innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {CacheInfoDAO.Data.class, Integer.TYPE, Object[].class });
 351                         innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"}});
 352                 } catch (InstantiationException e) {
 353                         // TODO Auto-generated catch block
 354                         e.printStackTrace();
 355                 } catch (IllegalAccessException e) {
 356                         // TODO Auto-generated catch block
 357                         e.printStackTrace();
 358                 } catch (IllegalArgumentException e) {
 359                         // TODO Auto-generated catch block
 360                         e.printStackTrace();
 361                 } catch (InvocationTargetException e) {
 362                         // TODO Auto-generated catch block
 363                         e.printStackTrace();
 364                 } catch (NoSuchMethodException e) {
 365                         // TODO Auto-generated catch block
 366                         e.printStackTrace();
 367                 } catch (SecurityException e) {
 368                         // TODO Auto-generated catch block
 369                         e.printStackTrace();
 370                 }
 371         }
 372
 373         @Test
 374         public void testCacheUpdate(){
 375                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 376                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 377                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test1: 1011", Env.REMOTE);
 378                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 379                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 380                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 381                 Mockito.doNothing().when(tt).done();
 382                 CacheInfoDAO.Data data1  = new CacheInfoDAO.Data();
 383                 PSInfo createPS = Mockito.mock(PSInfo.class);
 384                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 385                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data1);
 386
 387                 CacheInfoDAOImpl daoObj=null;
 388                 try {
 389                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test", createPS);
 390                 } catch (APIException | IOException e) {
 391                         // TODO Auto-generated catch block
 392                         e.printStackTrace();
 393                 }
 394                 Class[] classList = CacheInfoDAO.class.getDeclaredClasses();
 395                 Class<?> innerClass = null;
 396                 for(Class indCls:classList) {
 397                         if(indCls.getName().contains("CacheUpdate")) {
 398                                 innerClass = indCls;
 399                         }
 400                 }
 401         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 402         constructor.setAccessible(true);
 403         try {
 404                         Object obj = constructor.newInstance(env,Mockito.mock(HMangr.class), Mockito.mock(SecuritySetter.class), "12.0.0.1", 8080);
 405
 406                 Class<?> innerInnerClass = Class.forName("org.onap.aaf.auth.dao.cass.CacheInfoDAO$CacheUpdate$CacheClear");
 407             Constructor<?> innerConstructor = innerInnerClass.getDeclaredConstructors()[0];
 408             innerConstructor.setAccessible(true);
 409             Object innerClassObj = innerConstructor.newInstance(obj, trans);
 410
 411                         Method innnerClassMtd;
 412
 413                         CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 414                         Row row = Mockito.mock(Row.class);
 415                         Rcli rcli = Mockito.mock(Rcli.class);
 416                         URI uri = new URI("ftp","admin:admin@geeksforgeeks.org:1234","/path/data","tt","ttd");
 417                         Mockito.doReturn(uri).when(rcli).getURI();
 418                         Mockito.doReturn(Mockito.mock(org.onap.aaf.cadi.client.Future.class)).when(rcli).delete("/mgmt/cache/null/null", "application/Void+json;q=1.0;charset=utf-8;version=2.0,application/json;q=1.0;version=2.0,*/*;q=1.0");
 419
 420                         innnerClassMtd = innerInnerClass.getMethod("code", new Class[] {Rcli.class});
 421                         innnerClassMtd.invoke(innerClassObj, new Object[] {rcli});
 422
 423                         org.onap.aaf.cadi.client.Future futureObj = Mockito.mock(org.onap.aaf.cadi.client.Future.class);
 424                         Mockito.doReturn(futureObj).when(rcli).delete("/mgmt/cache/null/null", "application/Void+json;q=1.0;charset=utf-8;version=2.0,application/json;q=1.0;version=2.0,*/*;q=1.0");
 425                         Mockito.doReturn(true).when(futureObj).get(0);
 426                         innnerClassMtd.invoke(innerClassObj, new Object[] {rcli});
 427
 428                         uri = new URI("ftp","12.0.0.1:8080","/path/data","tt","ttd");
 429                         Mockito.doReturn(uri).when(rcli).getURI();
 430                         innnerClassMtd.invoke(innerClassObj, new Object[] {rcli});
 431                 } catch (InstantiationException e) {
 432                         // TODO Auto-generated catch block
 433                         e.printStackTrace();
 434                 } catch (IllegalAccessException e) {
 435                         // TODO Auto-generated catch block
 436                         e.printStackTrace();
 437                 } catch (IllegalArgumentException e) {
 438                         // TODO Auto-generated catch block
 439                         e.printStackTrace();
 440                 } catch (InvocationTargetException e) {
 441                         // TODO Auto-generated catch block
 442                         e.printStackTrace();
 443                 }  catch (SecurityException e) {
 444                         // TODO Auto-generated catch block
 445                         e.printStackTrace();
 446                 } catch (ClassNotFoundException e) {
 447                         // TODO Auto-generated catch block
 448                         e.printStackTrace();
 449                 } catch (NoSuchMethodException e) {
 450                         // TODO Auto-generated catch block
 451                         e.printStackTrace();
 452                 } catch (URISyntaxException e) {
 453                         // TODO Auto-generated catch block
 454                         e.printStackTrace();
 455                 } catch (APIException e) {
 456                         // TODO Auto-generated catch block
 457                         e.printStackTrace();
 458                 } catch (CadiException e) {
 459                         // TODO Auto-generated catch block
 460                         e.printStackTrace();
 461                 }
 462         }
 463
 464         @Test
 465         public void testIntHolder(){
 466                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 467                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 468                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO Touch segments test1: 1011", Env.REMOTE);
 469                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 470                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 471                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 472                 Mockito.doNothing().when(tt).done();
 473                 CacheInfoDAO.Data data1  = new CacheInfoDAO.Data();
 474                 PSInfo createPS = Mockito.mock(PSInfo.class);
 475                 Result<ResultSet> rs = new Result<ResultSet>(null,0,"test",new String[0]);
 476                 Mockito.doReturn(rs).when(createPS).exec(trans, "CacheInfoDAOImpl CREATE", data1);
 477
 478                 CacheInfoDAOImpl daoObj=null;
 479                 try {
 480                         daoObj = new CacheInfoDAOImpl(trans, cluster, "test", createPS);
 481                 } catch (APIException | IOException e) {
 482                         // TODO Auto-generated catch block
 483                         e.printStackTrace();
 484                 }
 485                 Class[] classList = CacheInfoDAO.class.getDeclaredClasses();
 486                 Class<?> innerClass = null;
 487                 for(Class indCls:classList) {
 488                         if(indCls.getName().contains("CacheUpdate")) {
 489                                 innerClass = indCls;
 490                         }
 491                 }
 492         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 493         constructor.setAccessible(true);
 494         try {
 495                         Object obj = constructor.newInstance(env,Mockito.mock(HMangr.class), Mockito.mock(SecuritySetter.class), "12.0.0.1", 8080);
 496
 497                 Class<?> innerInnerClass = Class.forName("org.onap.aaf.auth.dao.cass.CacheInfoDAO$CacheUpdate$IntHolder");
 498             Constructor<?> innerConstructor = innerInnerClass.getDeclaredConstructors()[0];
 499             innerConstructor.setAccessible(true);
 500             int[] a = new int[10];
 501             Object innerClassObj = innerConstructor.newInstance(obj, a);
 502
 503                         Method innnerClassMtd=null;
 504
 505                         CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 506                         Row row = Mockito.mock(Row.class);
 507                         Rcli rcli = Mockito.mock(Rcli.class);
 508                         URI uri = new URI("ftp","admin:admin@geeksforgeeks.org:1234","/path/data","tt","ttd");
 509                         Mockito.doReturn(uri).when(rcli).getURI();
 510                         Mockito.doReturn(Mockito.mock(org.onap.aaf.cadi.client.Future.class)).when(rcli).delete("/mgmt/cache/null/null", "application/Void+json;q=1.0;charset=utf-8;version=2.0,application/json;q=1.0;version=2.0,*/*;q=1.0");
 511
 512                         Method[] allMtds = innerInnerClass.getDeclaredMethods();
 513                         for(Method indMtd:allMtds) {
 514                                 if(indMtd.getName().contains("add")) {
 515                                         innnerClassMtd = indMtd;
 516                                 }
 517                         }
 518                         innnerClassMtd.invoke(innerClassObj, new Object[] {a});
 519
 520
 521                 } catch (InstantiationException e) {
 522                         // TODO Auto-generated catch block
 523                         e.printStackTrace();
 524                 } catch (IllegalAccessException e) {
 525                         // TODO Auto-generated catch block
 526                         e.printStackTrace();
 527                 } catch (IllegalArgumentException e) {
 528                         // TODO Auto-generated catch block
 529                         e.printStackTrace();
 530                 } catch (InvocationTargetException e) {
 531                         // TODO Auto-generated catch block
 532                         e.printStackTrace();
 533                 }  catch (SecurityException e) {
 534                         // TODO Auto-generated catch block
 535                         e.printStackTrace();
 536                 } catch (ClassNotFoundException e) {
 537                         // TODO Auto-generated catch block
 538                         e.printStackTrace();
 539                 } catch (URISyntaxException e) {
 540                         // TODO Auto-generated catch block
 541                         e.printStackTrace();
 542                 } catch (APIException e) {
 543                         // TODO Auto-generated catch block
 544                         e.printStackTrace();
 545                 } catch (CadiException e) {
 546                         // TODO Auto-generated catch block
 547                         e.printStackTrace();
 548                 }
 549         }
 550
 551         //@Test
 552         public void testSecondConstructor() {
 553                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 554                 Mockito.doReturn(tt).when(trans).start("CacheInfoDAO CREATE", Env.REMOTE);
 555                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 556                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 557                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CacheInfoDAO", Env.SUB);
 558                 Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE);
 559                 Mockito.doNothing().when(tt).done();
 560                 CacheInfoDAO.Data data  = new CacheInfoDAO.Data();
 561                 AbsCassDAO absCassDAO = Mockito.mock(AbsCassDAO.class);
 562
 563                 try {
 564                         CacheInfoDAO daoObj = new CacheInfoDAO(trans, absCassDAO);
 565                 } catch (APIException | IOException e) {
 566                         // TODO Auto-generated catch block
 567                         e.printStackTrace();
 568                 }
 569         }
 570 }
 571
 572 class CacheInfoDAOImpl extends CacheInfoDAO{
 573
 574         public CacheInfoDAOImpl(AuthzTrans trans, Cluster cluster, String keyspace,CacheInfoDAO.Data data,PSInfo createPS  ) throws APIException, IOException {
 575                 super(trans, cluster, keyspace);
 576                 this.createPS = createPS;
 577 //              setPs(this, createPS, "psByUser");
 578 //              setPs(this, createPS, "psByApprover");
 579 //              setPs(this, createPS, "psByTicket");
 580 //              setPs(this, createPS, "psByStatus");
 581 //              setSession(this, Mockito.mock(Session.class));
 582         }
 583
 584         public CacheInfoDAOImpl(AuthzTrans trans, Cluster cluster, String keyspace,PSInfo readPS  ) throws APIException, IOException {
 585                 super(trans, cluster, keyspace);
 586                 this.readPS = readPS;
 587         }
 588
 589
 590         public void setPs(CacheInfoDAOImpl CacheInfoDAOObj, PSInfo psInfoObj, String methodName) {
 591                 Field nsDaoField;
 592                 try {
 593                         nsDaoField = CacheInfoDAO.class.getDeclaredField(methodName);
 594
 595                         nsDaoField.setAccessible(true);
 596                 // remove final modifier from field
 597                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 598                 modifiersField.setAccessible(true);
 599 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 600
 601                 nsDaoField.set(CacheInfoDAOObj, psInfoObj);
 602                 } catch (NoSuchFieldException | SecurityException e) {
 603                         // TODO Auto-generated catch block
 604                         e.printStackTrace();
 605                 } catch (IllegalArgumentException e) {
 606                         // TODO Auto-generated catch block
 607                         e.printStackTrace();
 608                 } catch (IllegalAccessException e) {
 609                         // TODO Auto-generated catch block
 610                         e.printStackTrace();
 611                 }
 612         }
 613
 614
 615         public void setSession(CacheInfoDAOImpl CacheInfoDAOObj, Session session) {
 616                 Field nsDaoField;
 617                 try {
 618                         nsDaoField = AbsCassDAO.class.getDeclaredField("session");
 619
 620                         nsDaoField.setAccessible(true);
 621                 // remove final modifier from field
 622                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 623                 modifiersField.setAccessible(true);
 624 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 625                 nsDaoField.set(CacheInfoDAOObj, session);
 626                 } catch (NoSuchFieldException | SecurityException e) {
 627                         // TODO Auto-generated catch block
 628                         e.printStackTrace();
 629                 } catch (IllegalArgumentException e) {
 630                         // TODO Auto-generated catch block
 631                         e.printStackTrace();
 632                 } catch (IllegalAccessException e) {
 633                         // TODO Auto-generated catch block
 634                         e.printStackTrace();
 635                 }
 636         }
 637
 638 }