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

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.auth.dao.cass;
  23
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.MockitoAnnotations.initMocks;
  26
  27 import java.io.IOException;
  28 import java.lang.reflect.Constructor;
  29 import java.lang.reflect.Field;
  30 import java.lang.reflect.InvocationTargetException;
  31 import java.lang.reflect.Method;
  32 import java.nio.ByteBuffer;
  33 import java.util.Date;
  34 import java.util.List;
  35 import java.util.UUID;
  36
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.mockito.Mock;
  40 import org.mockito.Mockito;
  41 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
  42 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
  43 import org.onap.aaf.auth.dao.cass.HistoryDAO.Data;
  44 import org.onap.aaf.auth.dao.AbsCassDAO;
  45 import org.onap.aaf.auth.dao.CassDAOImpl;
  46 import org.onap.aaf.auth.dao.Loader;
  47 import org.onap.aaf.auth.env.AuthzTrans;
  48 import org.onap.aaf.auth.layer.Result;
  49 import org.onap.aaf.misc.env.APIException;
  50 import org.onap.aaf.misc.env.Env;
  51 import org.onap.aaf.misc.env.LogTarget;
  52 import org.onap.aaf.misc.env.TimeTaken;
  53
  54 import com.datastax.driver.core.Cluster;
  55 import com.datastax.driver.core.ResultSet;
  56 import com.datastax.driver.core.Row;
  57
  58 public class JU_HistoryDAO {
  59
  60     @Mock
  61     AuthzTrans trans;
  62     @Mock
  63     Cluster cluster;
  64
  65     @Before
  66     public void setUp() throws APIException, IOException {
  67         initMocks(this);
  68     }
  69
  70     @Test
  71     public void testInit() {
  72         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
  73     }
  74     @Test
  75     public void testNewInitedData() {
  76         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
  77         HistoryDAO.Data data = daoObj.newInitedData();
  78         assertTrue( Integer.toString(((new Date()).getYear())+1900).equalsIgnoreCase(Integer.toString(data.yr_mon).substring(0,4)) );
  79     }
  80
  81     @Test
  82     public void testCreateBatch() {
  83         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
  84         StringBuilder sb = new StringBuilder();
  85         HistoryDAO.Data data = new HistoryDAO.Data();
  86         daoObj.createBatch(sb, data);
  87         assertTrue(sb.toString().contains("INSERT INTO history"));
  88     }
  89
  90     @Test
  91     public void testReadByYYYYMM() {
  92         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
  93         AbsCassDAO<AuthzTrans, Data>.PSInfo psInfoObj = Mockito.mock(PSInfo.class);
  94         setAbsCassDAO(daoObj, psInfoObj, "readByYRMN");
  95
  96         ResultSet rs = Mockito.mock(ResultSet.class);
  97         Result<ResultSet>  rs1 = new Result<ResultSet>(rs,0,"test",new String[0]);
  98         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "yr_mon", 201905);
  99
 100         Result<List<Data>> retVal = daoObj.readByYYYYMM(trans, 201905);
 101         assertTrue(retVal.status !=1);
 102
 103         rs1 = new Result<ResultSet>(rs,1,"test",new String[0]);
 104         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "yr_mon", 201905);
 105         retVal = daoObj.readByYYYYMM(trans, 201905);
 106         assertTrue(retVal.status !=0);
 107     }
 108
 109     @Test
 110     public void testReadByUser() {
 111         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
 112         AbsCassDAO<AuthzTrans, Data>.PSInfo psInfoObj = Mockito.mock(PSInfo.class);
 113         setAbsCassDAO(daoObj, psInfoObj, "readByUser");
 114
 115         ResultSet rs = Mockito.mock(ResultSet.class);
 116         Result<ResultSet>  rs1 = new Result<ResultSet>(rs,0,"test",new String[0]);
 117         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "user", "test");
 118
 119         Result<List<Data>> retVal = daoObj.readByUser(trans, "test", 201905);
 120         assertTrue(retVal.status !=1);
 121
 122         rs1 = new Result<ResultSet>(rs,1,"test",new String[0]);
 123         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "user", "test");
 124         retVal = daoObj.readByUser(trans,"test", 201905);
 125         assertTrue(retVal.status !=0);
 126
 127         retVal = daoObj.readByUser(trans,"test");
 128         assertTrue(retVal.status !=0);
 129     }
 130
 131     @Test
 132     public void testReadBySubject() {
 133         HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test");
 134         AbsCassDAO<AuthzTrans, Data>.PSInfo psInfoObj = Mockito.mock(PSInfo.class);
 135         setAbsCassDAO(daoObj, psInfoObj, "readBySubject");
 136
 137         ResultSet rs = Mockito.mock(ResultSet.class);
 138         Result<ResultSet>  rs1 = new Result<ResultSet>(rs,0,"test",new String[0]);
 139         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "subject", "test", "test");
 140
 141         Result<List<Data>> retVal = daoObj.readBySubject(trans, "test", "test", 201905);
 142         assertTrue(retVal.status !=1);
 143
 144         rs1 = new Result<ResultSet>(rs,1,"test",new String[0]);
 145         Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "subject", "test", "test");
 146         retVal = daoObj.readBySubject(trans,"test", "test", 201905);
 147         assertTrue(retVal.status !=0);
 148
 149         retVal = daoObj.readBySubject(trans,"test", "test");
 150         assertTrue(retVal.status !=0);
 151     }
 152
 153     public void setAbsCassDAO(HistoryDAO HistoryDAOObj, PSInfo psInfoObj, String fieldName) {
 154         Field nsDaoField;
 155         try {
 156             nsDaoField = HistoryDAO.class.getDeclaredField(fieldName);
 157
 158             nsDaoField.setAccessible(true);
 159             // remove final modifier from field
 160             Field modifiersField = Field.class.getDeclaredField("modifiers");
 161             modifiersField.setAccessible(true);
 162 //            modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 163
 164             nsDaoField.set(HistoryDAOObj, psInfoObj);
 165         } catch (NoSuchFieldException | SecurityException e) {
 166             // TODO Auto-generated catch block
 167             e.printStackTrace();
 168         } catch (IllegalArgumentException e) {
 169             // TODO Auto-generated catch block
 170             e.printStackTrace();
 171         } catch (IllegalAccessException e) {
 172             // TODO Auto-generated catch block
 173             e.printStackTrace();
 174         }
 175     }
 176
 177
 178     @Test
 179     public void testSecondConstructor() {
 180         HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
 181
 182         HistoryDAO daoObj = new HistoryDAO(trans, historyDAO);
 183
 184     }
 185
 186     @Test
 187     public void testHistoryLoader(){
 188         Class<?> innerClass = null;
 189         Class<?>[] innerClassArr = HistoryDAO.class.getDeclaredClasses();
 190         for(Class indCls:innerClassArr) {
 191             if(indCls.getName().contains("HistLoader")) {
 192                 innerClass = indCls;
 193                 break;
 194             }
 195         }
 196
 197         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 198         constructor.setAccessible(true);
 199
 200         try {
 201             Object obj = constructor.newInstance(1);
 202             Method innnerClassMtd;
 203
 204             HistoryDAO.Data data  = new HistoryDAO.Data();
 205             Row row = Mockito.mock(Row.class);
 206             ByteBuffer bbObj = ByteBuffer.allocateDirect(10);
 207             bbObj.limit(7);
 208             bbObj.put(0, new Byte("0"));
 209             bbObj.put(1, new Byte("1"));
 210             bbObj.put(2, new Byte("2"));
 211             Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1);
 212
 213             innnerClassMtd = innerClass.getMethod("load", new Class[] {HistoryDAO.Data.class, Row.class});
 214             innnerClassMtd.invoke(obj, new Object[] {data, row});
 215
 216             innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {HistoryDAO.Data.class, Integer.TYPE, Object[].class });
 217             innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} });
 218 //
 219             innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {HistoryDAO.Data.class, Integer.TYPE, Object[].class });
 220             innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 221
 222         } catch (InstantiationException e) {
 223             // TODO Auto-generated catch block
 224             e.printStackTrace();
 225         } catch (IllegalAccessException e) {
 226             // TODO Auto-generated catch block
 227             e.printStackTrace();
 228         } catch (IllegalArgumentException e) {
 229             // TODO Auto-generated catch block
 230             e.printStackTrace();
 231         } catch (InvocationTargetException e) {
 232             // TODO Auto-generated catch block
 233             e.printStackTrace();
 234         } catch (NoSuchMethodException e) {
 235             // TODO Auto-generated catch block
 236             e.printStackTrace();
 237         } catch (SecurityException e) {
 238             // TODO Auto-generated catch block
 239             e.printStackTrace();
 240         }
 241     }
 242
 243     @Test
 244     public void testYYYYMM(){
 245         Class<?> innerClass = null;
 246         Class<?>[] innerClassArr = HistoryDAO.class.getDeclaredClasses();
 247         for(Class indCls:innerClassArr) {
 248             if(indCls.getName().contains("YYYYMM")) {
 249                 innerClass = indCls;
 250                 break;
 251             }
 252         }
 253
 254         Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
 255         constructor.setAccessible(true);
 256         int yyyymm[] = new int[2];
 257         try {
 258             Object obj = constructor.newInstance(new HistoryDAO(trans, cluster, "test"), yyyymm);
 259             Method innnerClassMtd;
 260
 261             HistoryDAO.Data data  = new HistoryDAO.Data();
 262             Row row = Mockito.mock(Row.class);
 263             ByteBuffer bbObj = ByteBuffer.allocateDirect(10);
 264             bbObj.limit(7);
 265             bbObj.put(0, new Byte("0"));
 266             bbObj.put(1, new Byte("1"));
 267             bbObj.put(2, new Byte("2"));
 268             Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1);
 269
 270             innnerClassMtd = innerClass.getMethod("ok", new Class[] {HistoryDAO.Data.class});
 271             innnerClassMtd.invoke(obj, new Object[] {data});
 272
 273             data.yr_mon=201904;
 274             innnerClassMtd.invoke(obj, new Object[] {data});
 275
 276         } catch (InstantiationException e) {
 277             // TODO Auto-generated catch block
 278             e.printStackTrace();
 279         } catch (IllegalAccessException e) {
 280             // TODO Auto-generated catch block
 281             e.printStackTrace();
 282         } catch (IllegalArgumentException e) {
 283             // TODO Auto-generated catch block
 284             e.printStackTrace();
 285         } catch (InvocationTargetException e) {
 286             // TODO Auto-generated catch block
 287             e.printStackTrace();
 288         } catch (NoSuchMethodException e) {
 289             // TODO Auto-generated catch block
 290             e.printStackTrace();
 291         } catch (SecurityException e) {
 292             // TODO Auto-generated catch block
 293             e.printStackTrace();
 294         }
 295     }
 296
 297 }
 298
 299 class HistoryDAOImpl extends HistoryDAO{
 300
 301
 302     public HistoryDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS  ) throws APIException, IOException {
 303         super(trans, historyDAO);
 304         setPs(this, readPS, "createPS");
 305     }
 306
 307     public void setPs(HistoryDAOImpl HistoryDAOObj, PSInfo psInfoObj, String methodName) {
 308         Field nsDaoField;
 309         try {
 310             nsDaoField = CassDAOImpl.class.getDeclaredField(methodName);
 311
 312             nsDaoField.setAccessible(true);
 313             // remove final modifier from field
 314             Field modifiersField = Field.class.getDeclaredField("modifiers");
 315             modifiersField.setAccessible(true);
 316 //            modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 317
 318             nsDaoField.set(HistoryDAOObj, psInfoObj);
 319         } catch (NoSuchFieldException | SecurityException e) {
 320             // TODO Auto-generated catch block
 321             e.printStackTrace();
 322         } catch (IllegalArgumentException e) {
 323             // TODO Auto-generated catch block
 324             e.printStackTrace();
 325         } catch (IllegalAccessException e) {
 326             // TODO Auto-generated catch block
 327             e.printStackTrace();
 328         }
 329     }
 330
 331 }