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.ByteArrayInputStream;
  29 import java.io.ByteArrayOutputStream;
  30 import java.io.DataInputStream;
  31 import java.io.DataOutputStream;
  32 import java.io.FileNotFoundException;
  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                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 222                         DataOutputStream dos = new DataOutputStream(baos);
 223                         innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {NsDAO.Data.class, DataOutputStream.class });
 224                         innnerClassMtd.invoke(obj, new Object[] {data, dos });
 225
 226                         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 227                         DataInputStream dis = new DataInputStream(bais);
 228                         innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {NsDAO.Data.class, DataInputStream.class });
 229                         innnerClassMtd.invoke(obj, new Object[] {data, dis });
 230
 231                 } catch (InstantiationException e) {
 232                         // TODO Auto-generated catch block
 233                         e.printStackTrace();
 234                 } catch (IllegalAccessException e) {
 235                         // TODO Auto-generated catch block
 236                         e.printStackTrace();
 237                 } catch (IllegalArgumentException e) {
 238                         // TODO Auto-generated catch block
 239                         e.printStackTrace();
 240                 } catch (InvocationTargetException e) {
 241                         // TODO Auto-generated catch block
 242                         e.printStackTrace();
 243                 } catch (NoSuchMethodException e) {
 244                         // TODO Auto-generated catch block
 245                         e.printStackTrace();
 246                 } catch (SecurityException e) {
 247                         // TODO Auto-generated catch block
 248                         e.printStackTrace();
 249                 }
 250         }
 251         @Test
 252         public void testCreate() {
 253                 PSInfo psObj = Mockito.mock(PSInfo.class);
 254
 255                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 256                 NsDAO.Data data = new NsDAO.Data();
 257
 258                 Result<ResultSet>  rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
 259                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 260                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 261                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 262                 NsDAOImpl daoObj=null;
 263                 try {
 264                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 265                 } catch (APIException | IOException e) {
 266                         // TODO Auto-generated catch block
 267                         e.printStackTrace();
 268                 }
 269                 Mockito.doReturn("test user").when(trans).user();
 270
 271                 Result<NsDAO.Data> retVal = daoObj.create(trans,data);
 272                 assertTrue(retVal.status == 4);
 273
 274                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 275                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 276                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 277                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 278                 data.parent = "parent";
 279                 data.attrib = new HashMap<>();
 280                 data.attrib.put("test", "test");
 281
 282                 Field cbField;
 283                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 284                 try {
 285                         cbField = CassAccess.class.getDeclaredField("cb");
 286                         cbField.setAccessible(true);
 287                         cbField.set(daoObj, null);
 288                 } catch (NoSuchFieldException | SecurityException e) {
 289                         // TODO Auto-generated catch block
 290                         e.printStackTrace();
 291                 } catch (IllegalArgumentException e) {
 292                         // TODO Auto-generated catch block
 293                         e.printStackTrace();
 294                 } catch (IllegalAccessException e) {
 295                         // TODO Auto-generated catch block
 296                         e.printStackTrace();
 297                 }
 298
 299                 retVal = daoObj.create(trans,data);
 300                 assertTrue(retVal.status == 9);
 301
 302                 Field owningField;
 303                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 304                 try {
 305                         owningField = AbsCassDAO.class.getDeclaredField("owningDAO");
 306                         owningField.setAccessible(true);
 307                         owningField.set(daoObj, null);
 308                 } catch (NoSuchFieldException | SecurityException e) {
 309                         // TODO Auto-generated catch block
 310                         e.printStackTrace();
 311                 } catch (IllegalArgumentException e) {
 312                         // TODO Auto-generated catch block
 313                         e.printStackTrace();
 314                 } catch (IllegalAccessException e) {
 315                         // TODO Auto-generated catch block
 316                         e.printStackTrace();
 317                 }
 318                 retVal = daoObj.create(trans,data);
 319                 assertTrue(retVal.status == 0);
 320
 321         }
 322
 323         @Test
 324         public void testUpdate() {
 325                 PSInfo psObj = Mockito.mock(PSInfo.class);
 326
 327                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 328                 NsDAO.Data data = new NsDAO.Data();
 329
 330                 Result<ResultSet>  rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
 331                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 332                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 333                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 334                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 335                 NsDAOImpl daoObj=null;
 336                 try {
 337                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 338                 } catch (APIException | IOException e) {
 339                         // TODO Auto-generated catch block
 340                         e.printStackTrace();
 341                 }
 342                 Mockito.doReturn("test user").when(trans).user();
 343
 344                 Result<Void> retVal = daoObj.update(trans,data);
 345                 assertTrue(retVal.status == 4);
 346
 347                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 348                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 349                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 350                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 351                 data.parent = "parent";
 352                 data.attrib = new HashMap<>();
 353                 data.attrib.put("test", "test");
 354                 Field cbField;
 355                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 356                 try {
 357                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 358                         cbField.setAccessible(true);
 359                         cbField.set(daoObj, null);
 360                 } catch (NoSuchFieldException | SecurityException e) {
 361                         // TODO Auto-generated catch block
 362                         e.printStackTrace();
 363                 } catch (IllegalArgumentException e) {
 364                         // TODO Auto-generated catch block
 365                         e.printStackTrace();
 366                 } catch (IllegalAccessException e) {
 367                         // TODO Auto-generated catch block
 368                         e.printStackTrace();
 369                 }
 370
 371                 retVal = daoObj.update(trans,data);
 372                 assertTrue(retVal.status == 0);
 373
 374                 ResultSet rsMock = Mockito.mock(ResultSet.class);
 375                 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
 376                 Mockito.doReturn(iteMock).when(rsMock).iterator();
 377                 Row rowMock = Mockito.mock(Row.class);
 378                 Mockito.doReturn(rowMock).when(iteMock).next();
 379                 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
 380                 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
 381                 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
 382                 retVal = daoObj.update(trans,data);
 383                 assertTrue(retVal.status == 0);
 384         }
 385
 386         @Test
 387         public void testRead() {
 388                 PSInfo psObj = Mockito.mock(PSInfo.class);
 389                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 390                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 391                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 392                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 393
 394                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 395                 NsDAO.Data data = new NsDAO.Data();
 396
 397                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 398                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 399                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 400                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 401                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 402                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 403                 NsDAOImpl daoObj=null;
 404                 try {
 405                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 406                 } catch (APIException | IOException e) {
 407                         // TODO Auto-generated catch block
 408                         e.printStackTrace();
 409                 }
 410                 Mockito.doReturn("test user").when(trans).user();
 411
 412                 Result<List<Data>> retVal = daoObj.read(trans,data);
 413                 assertTrue(retVal.status == 0);
 414
 415                 List<Data> dataAL= new ArrayList<>();
 416                 dataAL.add(data);
 417                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 418                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 419                 Field cbField;
 420                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 421                 try {
 422                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 423                         cbField.setAccessible(true);
 424                         cbField.set(daoObj, null);
 425                 } catch (NoSuchFieldException | SecurityException e) {
 426                         // TODO Auto-generated catch block
 427                         e.printStackTrace();
 428                 } catch (IllegalArgumentException e) {
 429                         // TODO Auto-generated catch block
 430                         e.printStackTrace();
 431                 } catch (IllegalAccessException e) {
 432                         // TODO Auto-generated catch block
 433                         e.printStackTrace();
 434                 }
 435                 retVal = daoObj.read(trans,data);
 436                 assertTrue(retVal.status == 0);
 437
 438         }
 439
 440         @Test
 441         public void testReadByObject() {
 442                 PSInfo psObj = Mockito.mock(PSInfo.class);
 443                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 444                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 445                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 446                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 447
 448                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 449                 NsDAO.Data data = new NsDAO.Data();
 450
 451                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 452                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 453                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 454                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
 455                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 456                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 457                 NsDAOImpl daoObj=null;
 458                 try {
 459                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 460                 } catch (APIException | IOException e) {
 461                         // TODO Auto-generated catch block
 462                         e.printStackTrace();
 463                 }
 464                 Mockito.doReturn("test user").when(trans).user();
 465
 466                 Result<List<Data>> retVal = daoObj.read(trans,new Object[] {});
 467                 assertTrue(retVal.status == 0);
 468
 469                 List<Data> dataAL= new ArrayList<>();
 470                 dataAL.add(data);
 471                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 472                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
 473                 Field cbField;
 474                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 475                 try {
 476                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 477                         cbField.setAccessible(true);
 478                         cbField.set(daoObj, null);
 479                 } catch (NoSuchFieldException | SecurityException e) {
 480                         // TODO Auto-generated catch block
 481                         e.printStackTrace();
 482                 } catch (IllegalArgumentException e) {
 483                         // TODO Auto-generated catch block
 484                         e.printStackTrace();
 485                 } catch (IllegalAccessException e) {
 486                         // TODO Auto-generated catch block
 487                         e.printStackTrace();
 488                 }
 489                 retVal = daoObj.read(trans,new Object[] {});
 490                 assertTrue(retVal.status == 0);
 491
 492         }
 493
 494         @Test
 495         public void testDelete() {
 496                 PSInfo psObj = Mockito.mock(PSInfo.class);
 497                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 498                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 499                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 500                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 501
 502                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 503                 NsDAO.Data data = new NsDAO.Data();
 504
 505                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 506                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 507                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 508                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 509                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 510                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 511                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 512                 NsDAOImpl daoObj=null;
 513                 try {
 514                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 515                 } catch (APIException | IOException e) {
 516                         // TODO Auto-generated catch block
 517                         e.printStackTrace();
 518                 }
 519                 Mockito.doReturn("test user").when(trans).user();
 520                 Field cbField;
 521                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 522                 try {
 523                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 524                         cbField.setAccessible(true);
 525                         cbField.set(daoObj, null);
 526                 } catch (NoSuchFieldException | SecurityException e) {
 527                         // TODO Auto-generated catch block
 528                         e.printStackTrace();
 529                 } catch (IllegalArgumentException e) {
 530                         // TODO Auto-generated catch block
 531                         e.printStackTrace();
 532                 } catch (IllegalAccessException e) {
 533                         // TODO Auto-generated catch block
 534                         e.printStackTrace();
 535                 }
 536
 537                 Result<Void> retVal = daoObj.delete(trans,data, false);
 538                 assertTrue(retVal.status == 0);
 539
 540                 List<Data> dataAL= new ArrayList<>();
 541                 dataAL.add(data);
 542                 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
 543                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 544
 545                 retVal = daoObj.delete(trans,data, false);
 546                 assertTrue(retVal.status == 0);
 547
 548         }
 549
 550         @Test
 551         public void testReadNsByAttrib() {
 552                 PSInfo psObj = Mockito.mock(PSInfo.class);
 553                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 554                 NsDAO.Data data = new NsDAO.Data();
 555                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 556                 NsDAOImpl daoObj=null;
 557                 try {
 558                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 559                 } catch (APIException | IOException e) {
 560                         // TODO Auto-generated catch block
 561                         e.printStackTrace();
 562                 }
 563
 564                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 565                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 566                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 567                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 568
 569                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 570                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 571                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 572                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 573                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 574                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 575
 576                 Mockito.doReturn("test user").when(trans).user();
 577                 Field cbField;
 578                 try {
 579                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 580                         cbField.setAccessible(true);
 581                         cbField.set(daoObj, null);
 582                 } catch (NoSuchFieldException | SecurityException e) {
 583                         // TODO Auto-generated catch block
 584                         e.printStackTrace();
 585                 } catch (IllegalArgumentException e) {
 586                         // TODO Auto-generated catch block
 587                         e.printStackTrace();
 588                 } catch (IllegalAccessException e) {
 589                         // TODO Auto-generated catch block
 590                         e.printStackTrace();
 591                 }
 592
 593                 Result<Set<String>> retVal = daoObj.readNsByAttrib(trans,"test");
 594                 assertTrue(retVal.status == 0);
 595
 596                 ResultSet rsMock = Mockito.mock(ResultSet.class);
 597                 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
 598                 Mockito.doReturn(iteMock).when(rsMock).iterator();
 599                 Row rowMock = Mockito.mock(Row.class);
 600                 Mockito.doReturn(rowMock).when(iteMock).next();
 601                 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
 602                 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
 603                 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
 604
 605                 retVal = daoObj.readNsByAttrib(trans,"test");
 606                 assertTrue(retVal.status == 0);
 607
 608         }
 609         @Test
 610         public void testAttribAdd() {
 611                 PSInfo psObj = Mockito.mock(PSInfo.class);
 612                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 613                 NsDAO.Data data = new NsDAO.Data();
 614                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 615                 NsDAOImpl daoObj=null;
 616                 try {
 617                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 618                 } catch (APIException | IOException e) {
 619                         // TODO Auto-generated catch block
 620                         e.printStackTrace();
 621                 }
 622
 623                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 624                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 625                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 626                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 627
 628                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 629                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 630                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 631                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 632                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 633                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 634
 635                 Mockito.doReturn("test user").when(trans).user();
 636                 Field cbField;
 637                 try {
 638                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 639                         cbField.setAccessible(true);
 640                         cbField.set(daoObj, null);
 641                 } catch (NoSuchFieldException | SecurityException e) {
 642                         // TODO Auto-generated catch block
 643                         e.printStackTrace();
 644                 } catch (IllegalArgumentException e) {
 645                         // TODO Auto-generated catch block
 646                         e.printStackTrace();
 647                 } catch (IllegalAccessException e) {
 648                         // TODO Auto-generated catch block
 649                         e.printStackTrace();
 650                 }
 651
 652                 Result<Void> retVal = daoObj.attribAdd(trans, "test", "test", "test");
 653                 assertTrue(retVal.status == 0);
 654         }
 655
 656         @Test
 657         public void testAttribRemove() {
 658                 PSInfo psObj = Mockito.mock(PSInfo.class);
 659                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 660                 NsDAO.Data data = new NsDAO.Data();
 661                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 662                 NsDAOImpl daoObj=null;
 663                 try {
 664                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 665                 } catch (APIException | IOException e) {
 666                         // TODO Auto-generated catch block
 667                         e.printStackTrace();
 668                 }
 669
 670                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 671                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 672                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 673                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 674
 675                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 676                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 677                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 678                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 679                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 680                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 681
 682                 Mockito.doReturn("test user").when(trans).user();
 683                 Field cbField;
 684                 try {
 685                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 686                         cbField.setAccessible(true);
 687                         cbField.set(daoObj, null);
 688                 } catch (NoSuchFieldException | SecurityException e) {
 689                         // TODO Auto-generated catch block
 690                         e.printStackTrace();
 691                 } catch (IllegalArgumentException e) {
 692                         // TODO Auto-generated catch block
 693                         e.printStackTrace();
 694                 } catch (IllegalAccessException e) {
 695                         // TODO Auto-generated catch block
 696                         e.printStackTrace();
 697                 }
 698
 699                 Result<Void> retVal = daoObj.attribRemove(trans, "test", "test");
 700                 assertTrue(retVal.status == 0);
 701         }
 702
 703         @Test
 704         public void testAddDescription() {
 705                 PSInfo psObj = Mockito.mock(PSInfo.class);
 706                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 707                 NsDAO.Data data = new NsDAO.Data();
 708                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 709                 NsDAOImpl daoObj=null;
 710                 try {
 711                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 712                 } catch (APIException | IOException e) {
 713                         // TODO Auto-generated catch block
 714                         e.printStackTrace();
 715                 }
 716
 717                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
 718                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
 719                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
 720                 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
 721
 722                 Result<List<Data>>  rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
 723                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
 724                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
 725                 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
 726                 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
 727                 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
 728
 729                  rs1 = new Result<List<Data>>(null,1,"test",new String[0]);
 730                 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
 731                 Mockito.doReturn("test user").when(trans).user();
 732                 Field cbField;
 733                 try {
 734                         cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
 735                         cbField.setAccessible(true);
 736                         cbField.set(daoObj, null);
 737                 } catch (NoSuchFieldException | SecurityException e) {
 738                         // TODO Auto-generated catch block
 739                         e.printStackTrace();
 740                 } catch (IllegalArgumentException e) {
 741                         // TODO Auto-generated catch block
 742                         e.printStackTrace();
 743                 } catch (IllegalAccessException e) {
 744                         // TODO Auto-generated catch block
 745                         e.printStackTrace();
 746                 }
 747
 748                 Result<Void> retVal = daoObj.addDescription(trans, "test", "test");
 749                 assertTrue(retVal.status == 0);
 750         }
 751
 752         @Test
 753         public void testGetChildren() {
 754                 PSInfo psObj = Mockito.mock(PSInfo.class);
 755                 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 756                 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
 757                 NsDAOImpl daoObj=null;
 758                 try {
 759                         daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
 760                 } catch (APIException | IOException e) {
 761                         // TODO Auto-generated catch block
 762                         e.printStackTrace();
 763                 }
 764
 765                 Result<List<Data>> retVal = daoObj.getChildren(trans, "test");
 766                 assertNull(retVal);
 767         }
 768
 769         @Test
 770         public void testData() {
 771                 NsDAO.Data data = new NsDAO.Data();
 772                 data.attrib = null;
 773                 data.attrib(true);
 774
 775                 data.attrib = new HashMap<>();
 776                 data.attrib(true);
 777
 778                 data.attrib(false);
 779                 data.attrib = new ConcurrentHashMap<>();
 780                 data.attrib(true);
 781
 782                 data.name="123";
 783                 data.split("test");
 784
 785                 data.toString();
 786         }
 787
 788 }
 789
 790 class NsDAOImpl extends NsDAO{
 791
 792
 793 //      public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS  ) throws APIException, IOException {
 794 //              super(trans, historyDAO);
 795 //              setSession(this, Mockito.mock(Session.class));
 796 //      }
 797
 798
 799         public NsDAOImpl(AuthzTrans trans, Cluster cluster, String keySpace, Session session)throws APIException, IOException {
 800                 super(trans, cluster, keySpace);
 801                 setSession(this, session);
 802         }
 803
 804
 805         public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO, CacheInfoDAO cacheInfoDAO,
 806                         org.onap.aaf.auth.dao.AbsCassDAO.PSInfo psObj, Session session) throws APIException, IOException {
 807                 super(trans, historyDAO, cacheInfoDAO);
 808                 setPs(this, psObj, "createPS");
 809                 setPs(this, psObj, "updatePS");
 810                 setPs(this, psObj, "readPS");
 811                 setPs(this, psObj, "deletePS");
 812                 setPsNs(this, psObj, "psNS");
 813                 setSession(this, session);
 814         }
 815         public void setPsNs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
 816                 Field nsDaoField;
 817                 try {
 818                         nsDaoField = NsDAO.class.getDeclaredField(methodName);
 819
 820                         nsDaoField.setAccessible(true);
 821                 // remove final modifier from field
 822                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 823                 modifiersField.setAccessible(true);
 824 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 825
 826                 nsDaoField.set(NsDAOObj, psInfoObj);
 827                 } catch (NoSuchFieldException | SecurityException e) {
 828                         // TODO Auto-generated catch block
 829                         e.printStackTrace();
 830                 } catch (IllegalArgumentException e) {
 831                         // TODO Auto-generated catch block
 832                         e.printStackTrace();
 833                 } catch (IllegalAccessException e) {
 834                         // TODO Auto-generated catch block
 835                         e.printStackTrace();
 836                 }
 837         }
 838
 839         public void setPs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
 840                 Field nsDaoField;
 841                 try {
 842                         nsDaoField = CassDAOImpl.class.getDeclaredField(methodName);
 843
 844                         nsDaoField.setAccessible(true);
 845                 // remove final modifier from field
 846                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 847                 modifiersField.setAccessible(true);
 848 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 849
 850                 nsDaoField.set(NsDAOObj, psInfoObj);
 851                 } catch (NoSuchFieldException | SecurityException e) {
 852                         // TODO Auto-generated catch block
 853                         e.printStackTrace();
 854                 } catch (IllegalArgumentException e) {
 855                         // TODO Auto-generated catch block
 856                         e.printStackTrace();
 857                 } catch (IllegalAccessException e) {
 858                         // TODO Auto-generated catch block
 859                         e.printStackTrace();
 860                 }
 861         }
 862         public void setSession(NsDAOImpl approvalDaoObj, Session session) {
 863                 Field nsDaoField;
 864                 try {
 865                         nsDaoField = AbsCassDAO.class.getDeclaredField("session");
 866
 867                         nsDaoField.setAccessible(true);
 868                 // remove final modifier from field
 869                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 870                 modifiersField.setAccessible(true);
 871 //              modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 872
 873                 nsDaoField.set(approvalDaoObj, session);
 874                 } catch (NoSuchFieldException | SecurityException e) {
 875                         // TODO Auto-generated catch block
 876                         e.printStackTrace();
 877                 } catch (IllegalArgumentException e) {
 878                         // TODO Auto-generated catch block
 879                         e.printStackTrace();
 880                 } catch (IllegalAccessException e) {
 881                         // TODO Auto-generated catch block
 882                         e.printStackTrace();
 883                 }
 884         }
 885 }