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 }