auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_NsDAO.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.assertNull;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.MockitoAnnotations.initMocks;
  27
  28 import java.io.DataInputStream;
  29 import java.io.DataOutputStream;
  30 import java.io.FileInputStream;
  31 import java.io.FileNotFoundException;
  32 import java.io.FileOutputStream;
  33 import java.io.IOException;
  34 import java.lang.reflect.Constructor;
  35 import java.lang.reflect.Field;
  36 import java.lang.reflect.InvocationTargetException;
  37 import java.lang.reflect.Method;
  38 import java.nio.ByteBuffer;
  39 import java.util.ArrayList;
  40 import java.util.HashMap;
  41 import java.util.Iterator;
  42 import java.util.List;
  43 import java.util.Set;
  44 import java.util.concurrent.ConcurrentHashMap;
  45
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.mockito.Mock;
  49 import org.mockito.Mockito;
  50 import org.onap.aaf.auth.dao.AbsCassDAO;
  51 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
  52 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
  53 import org.onap.aaf.auth.dao.CassAccess;
  54 import org.onap.aaf.auth.dao.CassDAOImpl;
  55 import org.onap.aaf.auth.dao.cass.NsDAO.Data;
  56 import org.onap.aaf.auth.env.AuthzTrans;
  57 import org.onap.aaf.auth.layer.Result;
  58 import org.onap.aaf.cadi.config.Config;
  59 import org.onap.aaf.misc.env.APIException;
  60 import org.onap.aaf.misc.env.Env;
  61 import org.onap.aaf.misc.env.LogTarget;
  62 import org.onap.aaf.misc.env.TimeTaken;
  63
  64 import com.datastax.driver.core.Cluster;
  65 import com.datastax.driver.core.ResultSet;
  66 import com.datastax.driver.core.Row;
  67 import com.datastax.driver.core.Session;
  68
  69 public class JU_NsDAO {
  70
  71         @Mock
  72     AuthzTrans trans;
  73         @Mock
  74         Cluster cluster;
  75         @Mock
  76         Session session;
  77         @Mock
  78         ResultSet rs;
  79
  80         @Before
  81         public void setUp() throws APIException, IOException {
  82                 initMocks(this);
  83                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn();
  84                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
  85                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
  86                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
  87                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init();
  88                 Mockito.doReturn(session).when(cluster).connect("test");
  89                 Mockito.doReturn(Mockito.mock(TimeTaken.class)).when(trans).start(Mockito.anyString(), Mockito.anyInt());
  90                 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE);
  91                 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE);
  92
  93                 Iterator<Row> ite = Mockito.mock(Iterator.class);
  94                 Mockito.doReturn(ite).when(rs).iterator();
  95                 Mockito.doReturn(rs).when(session).execute(Mockito.anyString());
  96         }
  97
  98         @Test
  99         public void testInit() {
 100                 try {
 101                         Session session =  Mockito.mock(Session.class);
 102                         new NsDAOImpl(trans, cluster, "test", session);
 103                 } catch (APIException | IOException e) {
 104                         // TODO Auto-generated catch block
 105                         e.printStackTrace();
 106                 }
 107         }
 108
 109         public void setPsByStartAndTarget(NsDAO NsDAOObj, PSInfo psInfoObj, String fieldName) {
 110                 Field nsDaoField;
 111                 try {
 112                         nsDaoField = NsDAO.class.getDeclaredField(fieldName);
 113
 114                         nsDaoField.setAccessible(true);
 115                 // remove final modifier from field
 116                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 117                 modifiersField.setAccessible(true);
 118 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 119
 120                 nsDaoField.set(NsDAOObj, psInfoObj);
 121                 } catch (NoSuchFieldException | SecurityException e) {
 122                         // TODO Auto-generated catch block
 123                         e.printStackTrace();
 124                 } catch (IllegalArgumentException e) {
 125                         // TODO Auto-generated catch block
 126                         e.printStackTrace();
 127                 } catch (IllegalAccessException e) {
 128                         // TODO Auto-generated catch block
 129                         e.printStackTrace();
 130                 }
 131         }
 132
 133         @Test
 134         public void testWasMOdified() {
 135                 TimeTaken tt = Mockito.mock(TimeTaken.class);
 136                 Mockito.doReturn(tt).when(trans).start("NsDAO CREATE", Env.REMOTE);
 137                 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
 138                 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
 139                 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on NsDAO", Env.SUB);
 140                 Mockito.doReturn(tt).when(trans).start("DELETE Future",Env.REMOTE);
 141                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 142                 Mockito.doNothing().when(tt).done();
 143                 NsDAO.Data data  = new NsDAO.Data();
 144
 145                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 146                 Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
 147                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 148                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 149                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 150
 151                 NsDAO daoObj = null;
 152                 try {
 153                         daoObj = new NsDAO(trans, historyDAO, cacheInfoDAO);
 154                 } catch (APIException | IOException e) {
 155                         // TODO Auto-generated catch block
 156                         e.printStackTrace();
 157                 }
 158                 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"});
 159
 160                 daoObj.wasModified(trans, CRUD.create, data, new String[] {});
 161                 daoObj.wasModified(trans, CRUD.create, data, new String[] {null});
 162                 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test",null});
 163                 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"});
 164
 165                 rs1 = new Result<ResultSet>(null,1,"test",new Object[0]);
 166                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 167                 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"});
 168         }
 169
 170         @Test
 171         public void testSecondConstructor() {
 172                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 173                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 174
 175                 try {
 176                         new NsDAO(trans, historyDAO, cacheInfoDAO);
 177                 } catch (APIException | IOException e) {
 178                         // TODO Auto-generated catch block
 179                         e.printStackTrace();
 180                 }
 181
 182         }
 183
 184         @Test
 185         public void testNSLoader(){
 186                 Class<?> innerClass = null;
 187                 Class<?>[] innerClassArr = NsDAO.class.getDeclaredClasses();
 188                 for(Class<?> indCls:innerClassArr) {
 189                         if(indCls.getName().contains("NSLoader")) {
 190                                 innerClass = indCls;
 191                                 break;
 192                         }
 193                 }
 194
 195         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 196         constructor.setAccessible(true);
 197
 198         try {
 199
 200                         Object obj = constructor.newInstance(1);
 201                         Method innnerClassMtd;
 202
 203                         NsDAO.Data data  = new NsDAO.Data();
 204                         Row row = Mockito.mock(Row.class);
 205                         ByteBuffer bbObj = ByteBuffer.allocateDirect(10);
 206                         bbObj.limit(7);
 207                         bbObj.put(0, new Byte("0"));
 208                         bbObj.put(1, new Byte("1"));
 209                         bbObj.put(2, new Byte("2"));
 210                         Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1);
 211
 212                         innnerClassMtd = innerClass.getMethod("load", new Class[] {NsDAO.Data.class, Row.class});
 213                         innnerClassMtd.invoke(obj, new Object[] {data, row});
 214
 215                         innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {NsDAO.Data.class, Integer.TYPE, Object[].class });
 216                         innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} });
 217 //
 218                         innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {NsDAO.Data.class, Integer.TYPE, Object[].class });
 219                         innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 220
 221                         DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_NsDAOTest.java"));
 222                         innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {NsDAO.Data.class, DataOutputStream.class });
 223                         innnerClassMtd.invoke(obj, new Object[] {data, dos });
 224
 225                         DataInputStream dis = new DataInputStream(new FileInputStream("JU_NsDAOTest.java"));
 226                         innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {NsDAO.Data.class, DataInputStream.class });
 227                         innnerClassMtd.invoke(obj, new Object[] {data, dis });
 228
 229                 } catch (InstantiationException e) {
 230                         // TODO Auto-generated catch block
 231                         e.printStackTrace();
 232                 } catch (IllegalAccessException e) {
 233                         // TODO Auto-generated catch block
 234                         e.printStackTrace();
 235                 } catch (IllegalArgumentException e) {
 236                         // TODO Auto-generated catch block
 237                         e.printStackTrace();
 238                 } catch (InvocationTargetException e) {
 239                         // TODO Auto-generated catch block
 240                         e.printStackTrace();
 241                 } catch (NoSuchMethodException e) {
 242                         // TODO Auto-generated catch block
 243                         e.printStackTrace();
 244                 } catch (SecurityException e) {
 245                         // TODO Auto-generated catch block
 246                         e.printStackTrace();
 247                 } catch (FileNotFoundException e) {
 248                         // TODO Auto-generated catch block
 249                         e.printStackTrace();
 250                 }
 251         }
 252         @Test
 253         public void testCreate() {
 254                 PSInfo psObj = Mockito.mock(PSInfo.class);
 255
 256                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 257                 NsDAO.Data data = new NsDAO.Data();
 258
 259                 Result<ResultSet>  rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
 260                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 261                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 262                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 263                 NsDAOImpl daoObj=null;
 264                 try {
 265                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 266                 } catch (APIException | IOException e) {
 267                         // TODO Auto-generated catch block
 268                         e.printStackTrace();
 269                 }
 270                 Mockito.doReturn("test user").when(trans).user();
 271
 272                 Result<NsDAO.Data> retVal = daoObj.create(trans,data);
 273                 assertTrue(retVal.status == 4);
 274
 275                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 276                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 277                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 278                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 279                 data.parent = "parent";
 280                 data.attrib = new HashMap<>();
 281                 data.attrib.put("test", "test");
 282
 283                 Field cbField;
 284                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 285                 try {
 286                         cbField = CassAccess.class.getDeclaredField("cb");
 287                         cbField.setAccessible(true);
 288                         cbField.set(daoObj, null);
 289                 } catch (NoSuchFieldException | SecurityException e) {
 290                         // TODO Auto-generated catch block
 291                         e.printStackTrace();
 292                 } catch (IllegalArgumentException e) {
 293                         // TODO Auto-generated catch block
 294                         e.printStackTrace();
 295                 } catch (IllegalAccessException e) {
 296                         // TODO Auto-generated catch block
 297                         e.printStackTrace();
 298                 }
 299
 300                 retVal = daoObj.create(trans,data);
 301                 assertTrue(retVal.status == 9);
 302
 303                 Field owningField;
 304                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 305                 try {
 306                         owningField = AbsCassDAO.class.getDeclaredField("owningDAO");
 307                         owningField.setAccessible(true);
 308                         owningField.set(daoObj, null);
 309                 } catch (NoSuchFieldException | SecurityException e) {
 310                         // TODO Auto-generated catch block
 311                         e.printStackTrace();
 312                 } catch (IllegalArgumentException e) {
 313                         // TODO Auto-generated catch block
 314                         e.printStackTrace();
 315                 } catch (IllegalAccessException e) {
 316                         // TODO Auto-generated catch block
 317                         e.printStackTrace();
 318                 }
 319                 retVal = daoObj.create(trans,data);
 320                 assertTrue(retVal.status == 0);
 321
 322         }
 323
 324         @Test
 325         public void testUpdate() {
 326                 PSInfo psObj = Mockito.mock(PSInfo.class);
 327
 328                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 329                 NsDAO.Data data = new NsDAO.Data();
 330
 331                 Result<ResultSet>  rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
 332                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 333                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 334                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 335                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 336                 NsDAOImpl daoObj=null;
 337                 try {
 338                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 339                 } catch (APIException | IOException e) {
 340                         // TODO Auto-generated catch block
 341                         e.printStackTrace();
 342                 }
 343                 Mockito.doReturn("test user").when(trans).user();
 344
 345                 Result<Void> retVal = daoObj.update(trans,data);
 346                 assertTrue(retVal.status == 4);
 347
 348                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 349                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 350                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 351                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 352                 data.parent = "parent";
 353                 data.attrib = new HashMap<>();
 354                 data.attrib.put("test", "test");
 355                 Field cbField;
 356                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 357                 try {
 358                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 359                         cbField.setAccessible(true);
 360                         cbField.set(daoObj, null);
 361                 } catch (NoSuchFieldException | SecurityException e) {
 362                         // TODO Auto-generated catch block
 363                         e.printStackTrace();
 364                 } catch (IllegalArgumentException e) {
 365                         // TODO Auto-generated catch block
 366                         e.printStackTrace();
 367                 } catch (IllegalAccessException e) {
 368                         // TODO Auto-generated catch block
 369                         e.printStackTrace();
 370                 }
 371
 372                 retVal = daoObj.update(trans,data);
 373                 assertTrue(retVal.status == 0);
 374
 375                 ResultSet rsMock = Mockito.mock(ResultSet.class);
 376                 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
 377                 Mockito.doReturn(iteMock).when(rsMock).iterator();
 378                 Row rowMock = Mockito.mock(Row.class);
 379                 Mockito.doReturn(rowMock).when(iteMock).next();
 380                 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
 381                 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
 382                 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
 383                 retVal = daoObj.update(trans,data);
 384                 assertTrue(retVal.status == 0);
 385         }
 386
 387         @Test
 388         public void testRead() {
 389                 PSInfo psObj = Mockito.mock(PSInfo.class);
 390                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 391                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 392                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 393                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 394
 395                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 396                 NsDAO.Data data = new NsDAO.Data();
 397
 398                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 399                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 400                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 401                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 402                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 403                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 404                 NsDAOImpl daoObj=null;
 405                 try {
 406                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 407                 } catch (APIException | IOException e) {
 408                         // TODO Auto-generated catch block
 409                         e.printStackTrace();
 410                 }
 411                 Mockito.doReturn("test user").when(trans).user();
 412
 413                 Result<List<Data>> retVal = daoObj.read(trans,data);
 414                 assertTrue(retVal.status == 0);
 415
 416                 List<Data> dataAL= new ArrayList<>();
 417                 dataAL.add(data);
 418                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 419                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 420                 Field cbField;
 421                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 422                 try {
 423                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 424                         cbField.setAccessible(true);
 425                         cbField.set(daoObj, null);
 426                 } catch (NoSuchFieldException | SecurityException e) {
 427                         // TODO Auto-generated catch block
 428                         e.printStackTrace();
 429                 } catch (IllegalArgumentException e) {
 430                         // TODO Auto-generated catch block
 431                         e.printStackTrace();
 432                 } catch (IllegalAccessException e) {
 433                         // TODO Auto-generated catch block
 434                         e.printStackTrace();
 435                 }
 436                 retVal = daoObj.read(trans,data);
 437                 assertTrue(retVal.status == 0);
 438
 439         }
 440
 441         @Test
 442         public void testReadByObject() {
 443                 PSInfo psObj = Mockito.mock(PSInfo.class);
 444                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 445                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 446                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 447                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 448
 449                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 450                 NsDAO.Data data = new NsDAO.Data();
 451
 452                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 453                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 454                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 455                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
 456                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 457                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 458                 NsDAOImpl daoObj=null;
 459                 try {
 460                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 461                 } catch (APIException | IOException e) {
 462                         // TODO Auto-generated catch block
 463                         e.printStackTrace();
 464                 }
 465                 Mockito.doReturn("test user").when(trans).user();
 466
 467                 Result<List<Data>> retVal = daoObj.read(trans,new Object[] {});
 468                 assertTrue(retVal.status == 0);
 469
 470                 List<Data> dataAL= new ArrayList<>();
 471                 dataAL.add(data);
 472                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 473                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
 474                 Field cbField;
 475                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 476                 try {
 477                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 478                         cbField.setAccessible(true);
 479                         cbField.set(daoObj, null);
 480                 } catch (NoSuchFieldException | SecurityException e) {
 481                         // TODO Auto-generated catch block
 482                         e.printStackTrace();
 483                 } catch (IllegalArgumentException e) {
 484                         // TODO Auto-generated catch block
 485                         e.printStackTrace();
 486                 } catch (IllegalAccessException e) {
 487                         // TODO Auto-generated catch block
 488                         e.printStackTrace();
 489                 }
 490                 retVal = daoObj.read(trans,new Object[] {});
 491                 assertTrue(retVal.status == 0);
 492
 493         }
 494
 495         @Test
 496         public void testDelete() {
 497                 PSInfo psObj = Mockito.mock(PSInfo.class);
 498                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 499                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 500                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 501                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 502
 503                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 504                 NsDAO.Data data = new NsDAO.Data();
 505
 506                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 507                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 508                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 509                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 510                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 511                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 512                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 513                 NsDAOImpl daoObj=null;
 514                 try {
 515                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 516                 } catch (APIException | IOException e) {
 517                         // TODO Auto-generated catch block
 518                         e.printStackTrace();
 519                 }
 520                 Mockito.doReturn("test user").when(trans).user();
 521                 Field cbField;
 522                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 523                 try {
 524                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 525                         cbField.setAccessible(true);
 526                         cbField.set(daoObj, null);
 527                 } catch (NoSuchFieldException | SecurityException e) {
 528                         // TODO Auto-generated catch block
 529                         e.printStackTrace();
 530                 } catch (IllegalArgumentException e) {
 531                         // TODO Auto-generated catch block
 532                         e.printStackTrace();
 533                 } catch (IllegalAccessException e) {
 534                         // TODO Auto-generated catch block
 535                         e.printStackTrace();
 536                 }
 537
 538                 Result<Void> retVal = daoObj.delete(trans,data, false);
 539                 assertTrue(retVal.status == 0);
 540
 541                 List<Data> dataAL= new ArrayList<>();
 542                 dataAL.add(data);
 543                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 544                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 545
 546                 retVal = daoObj.delete(trans,data, false);
 547                 assertTrue(retVal.status == 0);
 548
 549         }
 550
 551         @Test
 552         public void testReadNsByAttrib() {
 553                 PSInfo psObj = Mockito.mock(PSInfo.class);
 554                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 555                 NsDAO.Data data = new NsDAO.Data();
 556                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 557                 NsDAOImpl daoObj=null;
 558                 try {
 559                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 560                 } catch (APIException | IOException e) {
 561                         // TODO Auto-generated catch block
 562                         e.printStackTrace();
 563                 }
 564
 565                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 566                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 567                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 568                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 569
 570                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 571                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 572                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 573                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 574                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 575                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 576
 577                 Mockito.doReturn("test user").when(trans).user();
 578                 Field cbField;
 579                 try {
 580                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 581                         cbField.setAccessible(true);
 582                         cbField.set(daoObj, null);
 583                 } catch (NoSuchFieldException | SecurityException e) {
 584                         // TODO Auto-generated catch block
 585                         e.printStackTrace();
 586                 } catch (IllegalArgumentException e) {
 587                         // TODO Auto-generated catch block
 588                         e.printStackTrace();
 589                 } catch (IllegalAccessException e) {
 590                         // TODO Auto-generated catch block
 591                         e.printStackTrace();
 592                 }
 593
 594                 Result<Set<String>> retVal = daoObj.readNsByAttrib(trans,"test");
 595                 assertTrue(retVal.status == 0);
 596
 597                 ResultSet rsMock = Mockito.mock(ResultSet.class);
 598                 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
 599                 Mockito.doReturn(iteMock).when(rsMock).iterator();
 600                 Row rowMock = Mockito.mock(Row.class);
 601                 Mockito.doReturn(rowMock).when(iteMock).next();
 602                 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
 603                 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
 604                 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
 605
 606                 retVal = daoObj.readNsByAttrib(trans,"test");
 607                 assertTrue(retVal.status == 0);
 608
 609         }
 610         @Test
 611         public void testAttribAdd() {
 612                 PSInfo psObj = Mockito.mock(PSInfo.class);
 613                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 614                 NsDAO.Data data = new NsDAO.Data();
 615                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 616                 NsDAOImpl daoObj=null;
 617                 try {
 618                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 619                 } catch (APIException | IOException e) {
 620                         // TODO Auto-generated catch block
 621                         e.printStackTrace();
 622                 }
 623
 624                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 625                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 626                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 627                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 628
 629                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 630                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 631                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 632                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 633                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 634                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 635
 636                 Mockito.doReturn("test user").when(trans).user();
 637                 Field cbField;
 638                 try {
 639                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 640                         cbField.setAccessible(true);
 641                         cbField.set(daoObj, null);
 642                 } catch (NoSuchFieldException | SecurityException e) {
 643                         // TODO Auto-generated catch block
 644                         e.printStackTrace();
 645                 } catch (IllegalArgumentException e) {
 646                         // TODO Auto-generated catch block
 647                         e.printStackTrace();
 648                 } catch (IllegalAccessException e) {
 649                         // TODO Auto-generated catch block
 650                         e.printStackTrace();
 651                 }
 652
 653                 Result<Void> retVal = daoObj.attribAdd(trans, "test", "test", "test");
 654                 assertTrue(retVal.status == 0);
 655         }
 656
 657         @Test
 658         public void testAttribRemove() {
 659                 PSInfo psObj = Mockito.mock(PSInfo.class);
 660                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 661                 NsDAO.Data data = new NsDAO.Data();
 662                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 663                 NsDAOImpl daoObj=null;
 664                 try {
 665                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 666                 } catch (APIException | IOException e) {
 667                         // TODO Auto-generated catch block
 668                         e.printStackTrace();
 669                 }
 670
 671                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 672                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 673                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 674                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 675
 676                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 677                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 678                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 679                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 680                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 681                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 682
 683                 Mockito.doReturn("test user").when(trans).user();
 684                 Field cbField;
 685                 try {
 686                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 687                         cbField.setAccessible(true);
 688                         cbField.set(daoObj, null);
 689                 } catch (NoSuchFieldException | SecurityException e) {
 690                         // TODO Auto-generated catch block
 691                         e.printStackTrace();
 692                 } catch (IllegalArgumentException e) {
 693                         // TODO Auto-generated catch block
 694                         e.printStackTrace();
 695                 } catch (IllegalAccessException e) {
 696                         // TODO Auto-generated catch block
 697                         e.printStackTrace();
 698                 }
 699
 700                 Result<Void> retVal = daoObj.attribRemove(trans, "test", "test");
 701                 assertTrue(retVal.status == 0);
 702         }
 703
 704         @Test
 705         public void testAddDescription() {
 706                 PSInfo psObj = Mockito.mock(PSInfo.class);
 707                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 708                 NsDAO.Data data = new NsDAO.Data();
 709                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 710                 NsDAOImpl daoObj=null;
 711                 try {
 712                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 713                 } catch (APIException | IOException e) {
 714                         // TODO Auto-generated catch block
 715                         e.printStackTrace();
 716                 }
 717
 718                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 719                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 720                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 721                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 722
 723                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 724                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 725                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 726                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 727                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 728                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 729
 730                  rs1 = new Result<List<Data>>(null,1,"test",new String[0]);
 731                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 732                 Mockito.doReturn("test user").when(trans).user();
 733                 Field cbField;
 734                 try {
 735                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 736                         cbField.setAccessible(true);
 737                         cbField.set(daoObj, null);
 738                 } catch (NoSuchFieldException | SecurityException e) {
 739                         // TODO Auto-generated catch block
 740                         e.printStackTrace();
 741                 } catch (IllegalArgumentException e) {
 742                         // TODO Auto-generated catch block
 743                         e.printStackTrace();
 744                 } catch (IllegalAccessException e) {
 745                         // TODO Auto-generated catch block
 746                         e.printStackTrace();
 747                 }
 748
 749                 Result<Void> retVal = daoObj.addDescription(trans, "test", "test");
 750                 assertTrue(retVal.status == 0);
 751         }
 752
 753         @Test
 754         public void testGetChildren() {
 755                 PSInfo psObj = Mockito.mock(PSInfo.class);
 756                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 757                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 758                 NsDAOImpl daoObj=null;
 759                 try {
 760                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 761                 } catch (APIException | IOException e) {
 762                         // TODO Auto-generated catch block
 763                         e.printStackTrace();
 764                 }
 765
 766                 Result<List<Data>> retVal = daoObj.getChildren(trans, "test");
 767                 assertNull(retVal);
 768         }
 769
 770         @Test
 771         public void testData() {
 772                 NsDAO.Data data = new NsDAO.Data();
 773                 data.attrib = null;
 774                 data.attrib(true);
 775
 776                 data.attrib = new HashMap<>();
 777                 data.attrib(true);
 778
 779                 data.attrib(false);
 780                 data.attrib = new ConcurrentHashMap<>();
 781                 data.attrib(true);
 782
 783                 data.name="123";
 784                 data.split("test");
 785
 786                 data.toString();
 787         }
 788
 789 }
 790
 791 class NsDAOImpl extends NsDAO{
 792
 793
 794 //      public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS  ) throws APIException, IOException {
 795 //              super(trans, historyDAO);
 796 //              setSession(this, Mockito.mock(Session.class));
 797 //      }
 798
 799
 800         public NsDAOImpl(AuthzTrans trans, Cluster cluster, String keySpace, Session session)throws APIException, IOException {
 801                 super(trans, cluster, keySpace);
 802                 setSession(this, session);
 803         }
 804
 805
 806         public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO, CacheInfoDAO cacheInfoDAO,
 807                         org.onap.aaf.auth.dao.AbsCassDAO.PSInfo psObj, Session session) throws APIException, IOException {
 808                 super(trans, historyDAO, cacheInfoDAO);
 809                 setPs(this, psObj, "createPS");
 810                 setPs(this, psObj, "updatePS");
 811                 setPs(this, psObj, "readPS");
 812                 setPs(this, psObj, "deletePS");
 813                 setPsNs(this, psObj, "psNS");
 814                 setSession(this, session);
 815         }
 816         public void setPsNs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
 817                 Field nsDaoField;
 818                 try {
 819                         nsDaoField = NsDAO.class.getDeclaredField(methodName);
 820
 821                         nsDaoField.setAccessible(true);
 822                 // remove final modifier from field
 823                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 824                 modifiersField.setAccessible(true);
 825 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 826
 827                 nsDaoField.set(NsDAOObj, psInfoObj);
 828                 } catch (NoSuchFieldException | SecurityException e) {
 829                         // TODO Auto-generated catch block
 830                         e.printStackTrace();
 831                 } catch (IllegalArgumentException e) {
 832                         // TODO Auto-generated catch block
 833                         e.printStackTrace();
 834                 } catch (IllegalAccessException e) {
 835                         // TODO Auto-generated catch block
 836                         e.printStackTrace();
 837                 }
 838         }
 839
 840         public void setPs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
 841                 Field nsDaoField;
 842                 try {
 843                         nsDaoField = CassDAOImpl.class.getDeclaredField(methodName);
 844
 845                         nsDaoField.setAccessible(true);
 846                 // remove final modifier from field
 847                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 848                 modifiersField.setAccessible(true);
 849 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 850
 851                 nsDaoField.set(NsDAOObj, psInfoObj);
 852                 } catch (NoSuchFieldException | SecurityException e) {
 853                         // TODO Auto-generated catch block
 854                         e.printStackTrace();
 855                 } catch (IllegalArgumentException e) {
 856                         // TODO Auto-generated catch block
 857                         e.printStackTrace();
 858                 } catch (IllegalAccessException e) {
 859                         // TODO Auto-generated catch block
 860                         e.printStackTrace();
 861                 }
 862         }
 863         public void setSession(NsDAOImpl approvalDaoObj, Session session) {
 864                 Field nsDaoField;
 865                 try {
 866                         nsDaoField = AbsCassDAO.class.getDeclaredField("session");
 867
 868                         nsDaoField.setAccessible(true);
 869                 // remove final modifier from field
 870                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 871                 modifiersField.setAccessible(true);
 872 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 873
 874                 nsDaoField.set(approvalDaoObj, session);
 875                 } catch (NoSuchFieldException | SecurityException e) {
 876                         // TODO Auto-generated catch block
 877                         e.printStackTrace();
 878                 } catch (IllegalArgumentException e) {
 879                         // TODO Auto-generated catch block
 880                         e.printStackTrace();
 881                 } catch (IllegalAccessException e) {
 882                         // TODO Auto-generated catch block
 883                         e.printStackTrace();
 884                 }
 885         }
 886 }