From 685a3eea830c15d2b26a1f2851251203fa4f6156 Mon Sep 17 00:00:00 2001 From: Sai Gandham Date: Fri, 10 May 2019 10:31:05 -0500 Subject: Add more junits to auth cass fixed exceptions and add more junits Issue-ID: AAF-111 Change-Id: Iffe75bbc87078896c37a70a549bfbcc39735a21d Signed-off-by: Sai Gandham --- .../java/org/onap/aaf/auth/dao/JU_CassAccess.java | 12 +- .../onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java | 6 +- .../org/onap/aaf/auth/dao/cass/JU_CertDAOTest.java | 385 +++++++++++++++++++++ .../onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java | 315 +++++++++++++++++ .../org/onap/aaf/auth/dao/cass/JU_DelegateDAO.java | 187 ++++++++++ .../org/onap/aaf/auth/dao/cass/JU_FutureDAO.java | 293 ++++++++++++++++ .../org/onap/aaf/auth/dao/cass/JU_HistoryDAO.java | 331 ++++++++++++++++++ .../org/onap/aaf/auth/dao/cass/JU_LocateDAO.java | 319 +++++++++++++++++ 8 files changed, 1839 insertions(+), 9 deletions(-) create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CertDAOTest.java create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_DelegateDAO.java create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_FutureDAO.java create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_HistoryDAO.java create mode 100644 auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java (limited to 'auth/auth-cass/src/test') diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_CassAccess.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_CassAccess.java index cb6008bd..c06cd5c1 100644 --- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_CassAccess.java +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_CassAccess.java @@ -64,11 +64,11 @@ public class JU_CassAccess { cassAccess = new CassAccess(); } - - @Test(expected=APIException.class) - public void testCluster() throws APIException, IOException { - cassAccess.cluster(envMock, prefix); - - } +// +// @Test(expected=APIException.class) +// public void testCluster() throws APIException, IOException { +//// cassAccess.cluster(envMock, prefix); +// +// } } diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java index aa6d9f31..ce32615d 100644 --- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java @@ -269,13 +269,13 @@ public class JU_CacheInfoDAO { CacheInfoDAOImpl daoObj=null; try { daoObj = new CacheInfoDAOImpl(trans, cluster, "test",data, createPS); - Date retVal = daoObj.get(trans, "test", 1011); -// assertTrue(retVal.status == 0); - retVal = daoObj.get(trans, "test1", 1011); } catch (APIException | IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } + Date retVal = daoObj.get(trans, "test", 1011); +// assertTrue(retVal.status == 0); + retVal = daoObj.get(trans, "test1", 1011); } @Test diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CertDAOTest.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CertDAOTest.java new file mode 100644 index 00000000..a4b24c37 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CertDAOTest.java @@ -0,0 +1,385 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.math.BigInteger; +import java.nio.ByteBuffer; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO; +import org.onap.aaf.auth.dao.AbsCassDAO.CRUD; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.dao.CassAccess; +import org.onap.aaf.auth.env.AuthzEnv; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.cadi.config.Config; +import org.onap.aaf.misc.env.APIException; +import org.onap.aaf.misc.env.Decryptor; +import org.onap.aaf.misc.env.Env; +import org.onap.aaf.misc.env.LogTarget; +import org.onap.aaf.misc.env.TimeTaken; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.ResultSet; +import com.datastax.driver.core.Row; +import com.datastax.driver.core.Session; + +public class JU_CertDAOTest { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + @Mock + Session session; + @Mock + AuthzEnv env; + @Mock + LogTarget logTarget; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init(); + Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE); + Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE); + Mockito.doReturn(session).when(cluster).connect("test"); + } + + @Test + public void testInit() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("CertDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CertDAO", Env.SUB); + Mockito.doNothing().when(tt).done(); + CertDAO.Data data = new CertDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + Result rs = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs).when(createPS).exec(trans, "CertDAOImpl CREATE", data); + + CertDAOImpl daoObj=null; + try { + daoObj = new CertDAOImpl(trans, cluster, "test",data, createPS); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + + @Test + public void testCertLoader(){ + + Class innerClass = CertDAO.class.getDeclaredClasses()[0]; + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + try { + Object obj = constructor.newInstance(1); + Method innnerClassMtd; + + CertDAO.Data data = new CertDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {CertDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {CertDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} }); +// + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {CertDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + +// DataInputStream in = Mockito.mock(DataInputStream.class); +//// Mockito.doReturn(100).when(in).read(); +//// Mockito.doReturn(100).when(in).readInt(); +// innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {ArtiDAO.Data.class, DataInputStream.class }); +// innnerClassMtd.invoke(obj, new Object[] {data, in}); + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testWasMOdified() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("CertDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CertDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE); + Mockito.doNothing().when(tt).done(); + CertDAO.Data data = new CertDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + Result rs1 = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + + CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class); + Mockito.doReturn(rs1).when(cacheInfoDAO).touch(trans, CertDAO.TABLE, new int[1]); + + CertDAO daoObj = null; + try { + daoObj = new CertDAO(trans, historyDAO, cacheInfoDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"}); + + rs1 = new Result(null,1,"test",new String[0]); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + + Mockito.doReturn(rs1).when(cacheInfoDAO).touch(trans, CertDAO.TABLE, new int[1]); + + try { + daoObj = new CertDAO(trans, historyDAO, cacheInfoDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"}); + + daoObj.wasModified(trans, CRUD.delete, data, new String[] {"test"}); + daoObj.wasModified(trans, CRUD.delete, data, new String[] {"test", null}); + daoObj.wasModified(trans, CRUD.delete, data, new String[] {"test", "test"}); + daoObj.wasModified(trans, CRUD.delete, data, new String[] {null}); + daoObj.wasModified(trans, CRUD.delete, data, new String[] {}); + + try { + CertDAO.Data data1 = Mockito.mock(CertDAO.Data.class); + Mockito.doThrow(new IOException()).when(data1).bytify(); + Mockito.doReturn(new int[1]).when(data1).invalidate(Mockito.any()); + daoObj.wasModified(trans, CRUD.delete, data1, new String[] {}); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testRead() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("CertDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("CertDAO READ", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CertDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null); + Mockito.doReturn(Mockito.mock(Decryptor.class)).when(trans).decryptor(); + Mockito.doNothing().when(tt).done(); + CertDAO.Data data = new CertDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + Result rs1 = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + + CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class); + Mockito.doReturn(rs1).when(cacheInfoDAO).touch(trans, CertDAO.TABLE, new int[1]); + + CertDAO daoObj = null; + try { + daoObj = new CertDAO(trans, historyDAO, cacheInfoDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.read(trans, new Object[] {"test", BigInteger.ONE}); + Field cbField; + try { + cbField = CassAccess.class.getDeclaredField("cb"); + + cbField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + cbField.set(null, null); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.readX500(trans, "test"); + + try { + cbField = CassAccess.class.getDeclaredField("cb"); + + cbField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + cbField.set(null, null); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.readID(trans, "test"); + } + + + @Test + public void testSecondConstructor() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("CertDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on CertDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE); + Mockito.doNothing().when(tt).done(); + CertDAO.Data data = new CertDAO.Data(); + CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class); + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + + try { + CertDAO daoObj = new CertDAO(trans, historyDAO, cacheInfoDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } +} + +class CertDAOImpl extends CertDAO{ + + public CertDAOImpl(AuthzTrans trans, Cluster cluster, String keyspace,CertDAO.Data data,PSInfo createPS ) throws APIException, IOException { + super(trans, cluster, keyspace); + this.createPS = createPS; +// setPs(this, createPS, "psByUser"); +// setPs(this, createPS, "psByApprover"); +// setPs(this, createPS, "psByTicket"); +// setPs(this, createPS, "psByStatus"); +// setSession(this, Mockito.mock(Session.class)); + } + + public CertDAOImpl(AuthzTrans trans, Cluster cluster, String keyspace,PSInfo readPS ) throws APIException, IOException { + super(trans, cluster, keyspace); + this.readPS = readPS; + } + + + public void setPs(CertDAOImpl CertDAOObj, PSInfo psInfoObj, String methodName) { + Field nsDaoField; + try { + nsDaoField = CertDAO.class.getDeclaredField(methodName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(CertDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + public void setSession(CertDAOImpl CertDAOObj, Session session) { + Field nsDaoField; + try { + nsDaoField = AbsCassDAO.class.getDeclaredField("session"); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + nsDaoField.set(CertDAOObj, session); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java new file mode 100644 index 00000000..8981b0a6 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java @@ -0,0 +1,315 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO; +import org.onap.aaf.auth.dao.AbsCassDAO.CRUD; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.dao.cass.ConfigDAO.Data; +import org.onap.aaf.auth.dao.CassAccess; +import org.onap.aaf.auth.env.AuthzEnv; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.cadi.config.Config; +import org.onap.aaf.misc.env.APIException; +import org.onap.aaf.misc.env.Decryptor; +import org.onap.aaf.misc.env.Env; +import org.onap.aaf.misc.env.LogTarget; +import org.onap.aaf.misc.env.TimeTaken; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.PreparedStatement; +import com.datastax.driver.core.ResultSet; +import com.datastax.driver.core.Row; +import com.datastax.driver.core.Session; + +public class JU_ConfigDAOTest { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + @Mock + Session session; + @Mock + AuthzEnv env; + @Mock + LogTarget logTarget; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info(); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init(); + Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE); + Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE); + Mockito.doReturn(session).when(cluster).connect("test"); + } + + @Test + public void testInit() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("ConfigDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on ConfigDAO", Env.SUB); + Mockito.doNothing().when(tt).done(); + ConfigDAO.Data data = new ConfigDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + Result rs = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs).when(createPS).exec(trans, "ConfigDAOImpl CREATE", data); + + ConfigDAO daoObj=null; + try { + daoObj = new ConfigDAO(trans, cluster, "test"); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + + @Test + public void testConfigLoader(){ + + Class innerClass = ConfigDAO.class.getDeclaredClasses()[0]; + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + try { + Object obj = constructor.newInstance(1); + Method innnerClassMtd; + + ConfigDAO.Data data = new ConfigDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {ConfigDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {ConfigDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} }); +// + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {ConfigDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + + DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_ConfigDAOTest.java")); + innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {ConfigDAO.Data.class, DataOutputStream.class }); + innnerClassMtd.invoke(obj, new Object[] {data, dos }); + + DataInputStream dis = new DataInputStream(new FileInputStream("JU_ConfigDAOTest.java")); + innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {ConfigDAO.Data.class, DataInputStream.class }); + innnerClassMtd.invoke(obj, new Object[] {data, dis }); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testWasMOdified() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("ConfigDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on ConfigDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE); + Mockito.doNothing().when(tt).done(); + ConfigDAO.Data data = new ConfigDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + + ConfigDAO daoObj = null; + try { + daoObj = new ConfigDAO(trans, cluster, "test"); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"}); + + + + } + + @Test + public void testRead() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("ConfigDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("ConfigDAO READ", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo READ on ConfigDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start(Mockito.anyString(),Mockito.anyInt()); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100"); + Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null); + Mockito.doReturn(Mockito.mock(Decryptor.class)).when(trans).decryptor(); + Mockito.doNothing().when(tt).done(); + + Result> rs1 = new Result>(null,0,"test",new String[0]); + + + PSInfo psObj = Mockito.mock(PSInfo.class); + ConfigDAOImpl daoObj = null; + try { + daoObj = new ConfigDAOImpl(trans, cluster, "test",psObj); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + Mockito.doReturn(rs1).when(psObj).read(trans, "ConfigDAO READ", new Object[]{"test"}); + daoObj.readName(trans, "test"); + + + } + + + + @Test + public void testSecondConstructor() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("ConfigDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on ConfigDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE APPROVAL",Env.REMOTE); + Mockito.doNothing().when(tt).done(); + AbsCassDAO absDAO = Mockito.mock(AbsCassDAO.class); + + try { + ConfigDAO daoObj = new ConfigDAO(trans, absDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } +} + +class ConfigDAOImpl extends ConfigDAO{ + + + public ConfigDAOImpl(AuthzTrans trans, Cluster cluster, String keyspace,PSInfo readPS ) throws APIException, IOException { + super(trans, cluster, keyspace); + setPs(this, readPS, "psName"); + } + + + public void setPs(ConfigDAOImpl ConfigDAOObj, PSInfo psInfoObj, String methodName) { + Field nsDaoField; + try { + nsDaoField = ConfigDAO.class.getDeclaredField(methodName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(ConfigDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + public void setSession(ConfigDAOImpl ConfigDAOObj, Session session) { + Field nsDaoField; + try { + nsDaoField = AbsCassDAO.class.getDeclaredField("session"); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + nsDaoField.set(ConfigDAOObj, session); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_DelegateDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_DelegateDAO.java new file mode 100644 index 00000000..451cc720 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_DelegateDAO.java @@ -0,0 +1,187 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.nio.ByteBuffer; +import java.util.Date; +import java.util.List; +import java.util.TreeSet; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.misc.env.APIException; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.Row; + +public class JU_DelegateDAO { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + } + + @Test + public void testInit() { + DelegateDAO daoObj = new DelegateDAO(trans, cluster, "test"); +// daoObj. + } + @Test + public void testReadByDelegate() { + DelegateDAO daoObj = new DelegateDAO(trans, cluster, "test"); + + PSInfo psObj = Mockito.mock(PSInfo.class); + setPsDelegate(daoObj, psObj, "psByDelegate"); + + Result> rs1 = new Result>(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psObj).read(trans, "DelegateDAO READ", new Object[]{"test"}); + + daoObj.readByDelegate(trans, "test"); + } + + public void setPsDelegate(DelegateDAO delegateDAOObj, PSInfo psInfoObj, String fieldName) { + Field nsDaoField; + try { + nsDaoField = DelegateDAO.class.getDeclaredField(fieldName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(delegateDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testSecondConstructor() { + AbsCassDAO absDAO = Mockito.mock(AbsCassDAO.class); + + DelegateDAO daoObj = new DelegateDAO(trans, absDAO); + + } + + @Test + public void testDelegateLoader(){ + + Class innerClass = DelegateDAO.class.getDeclaredClasses()[1]; + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + try { + Object obj = constructor.newInstance(1); + Method innnerClassMtd; + + DelegateDAO.Data data = new DelegateDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {DelegateDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {DelegateDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} }); +// + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {DelegateDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + +// DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_DelegateDAOTest.java")); +// innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {DelegateDAO.Data.class, DataOutputStream.class }); +// innnerClassMtd.invoke(obj, new Object[] {data, dos }); + +// DataInputStream dis = new DataInputStream(new FileInputStream("JU_DelegateDAOTest.java")); +// innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {DelegateDAO.Data.class, DataInputStream.class }); +// innnerClassMtd.invoke(obj, new Object[] {data, dis }); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testData(){ + DelegateDAO.Data data = new DelegateDAO.Data(); + data.user="user"; + data.delegate="delegate"; + data.expires = new Date(); + try { + data.bytify(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_FutureDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_FutureDAO.java new file mode 100644 index 00000000..68764a60 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_FutureDAO.java @@ -0,0 +1,293 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.junit.Assert.assertTrue; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.nio.ByteBuffer; +import java.util.Date; +import java.util.List; +import java.util.UUID; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO.CRUD; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.dao.CassDAOImpl; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.misc.env.APIException; +import org.onap.aaf.misc.env.Env; +import org.onap.aaf.misc.env.LogTarget; +import org.onap.aaf.misc.env.TimeTaken; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.ResultSet; +import com.datastax.driver.core.Row; + +public class JU_FutureDAO { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + } + + @Test + public void testInit() { + FutureDAO daoObj = new FutureDAO(trans, cluster, "test"); +// daoObj. + } + @Test + public void testReadByStartAndTarget() { + FutureDAO daoObj = new FutureDAO(trans, cluster, "test"); + + PSInfo psObj = Mockito.mock(PSInfo.class); + setPsByStartAndTarget(daoObj, psObj, "psByStartAndTarget"); + + Result> rs1 = new Result>(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psObj).read(trans, "FutureDAO READ", new Object[]{"test"}); + + daoObj.readByStartAndTarget(trans,new Date(), "test"); + } + @Test + public void testCreate() { + PSInfo psObj = Mockito.mock(PSInfo.class); + + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + FutureDAO.Data data = new FutureDAO.Data(); + + Result rs1 = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psObj).exec(trans, "FutureDAOImpl CREATE", data); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + + FutureDAOImpl daoObj=null; + try { + daoObj = new FutureDAOImpl(trans, historyDAO, psObj); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + Mockito.doReturn("test user").when(trans).user(); + + Result retVal = daoObj.create(trans,data, "test"); + assertTrue(retVal.status == 0); + + StringBuilder sb = new StringBuilder(trans.user()); + sb.append(data.target); + sb.append(System.currentTimeMillis()); + data.id = UUID.nameUUIDFromBytes(sb.toString().getBytes()); + + rs1 = new Result(null,1,"test",new String[0]); + Mockito.doReturn(rs1).when(psObj).exec(trans, "FutureDAOImpl CREATE", data); + + retVal = daoObj.create(trans,data, "test"); + assertTrue(retVal.status != 0); + + + } + + public void setPsByStartAndTarget(FutureDAO FutureDAOObj, PSInfo psInfoObj, String fieldName) { + Field nsDaoField; + try { + nsDaoField = FutureDAO.class.getDeclaredField(fieldName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(FutureDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testWasMOdified() { + TimeTaken tt = Mockito.mock(TimeTaken.class); + Mockito.doReturn(tt).when(trans).start("FutureDAO CREATE", Env.REMOTE); + Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB); + Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB); + Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on FutureDAO", Env.SUB); + Mockito.doReturn(tt).when(trans).start("DELETE Future",Env.REMOTE); + Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error(); + Mockito.doNothing().when(tt).done(); + FutureDAO.Data data = new FutureDAO.Data(); + PSInfo createPS = Mockito.mock(PSInfo.class); + + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + Result rs1 = new Result(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + + FutureDAOImpl daoObj = null; + try { + daoObj = new FutureDAOImpl(trans, historyDAO, createPS ); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"}); + + daoObj.wasModified(trans, CRUD.create, data, new String[] {}); + daoObj.wasModified(trans, CRUD.create, data, new String[] {null}); + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test",null}); + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"}); + + rs1 = new Result(null,1,"test",new String[0]); + Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any()); + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"}); + } + + @Test + public void testSecondConstructor() { + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + + FutureDAO daoObj = new FutureDAO(trans, historyDAO); + + } + + @Test + public void testFutureLoader(){ + Class innerClass = null; + Class[] innerClassArr = FutureDAO.class.getDeclaredClasses(); + for(Class indCls:innerClassArr) { + if(indCls.getName().contains("FLoader")) { + innerClass = indCls; + break; + } + } + + Constructor constructor = innerClass.getDeclaredConstructors()[1]; + constructor.setAccessible(true); + + Constructor constructor1 = innerClass.getDeclaredConstructors()[0]; + constructor1.setAccessible(true); + try { + + Object obj = constructor.newInstance(1); + obj = constructor1.newInstance(); + Method innnerClassMtd; + + FutureDAO.Data data = new FutureDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {FutureDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {FutureDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} }); +// + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {FutureDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + +// DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_FutureDAOTest.java")); +// innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {FutureDAO.Data.class, DataOutputStream.class }); +// innnerClassMtd.invoke(obj, new Object[] {data, dos }); + +// DataInputStream dis = new DataInputStream(new FileInputStream("JU_FutureDAOTest.java")); +// innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {FutureDAO.Data.class, DataInputStream.class }); +// innnerClassMtd.invoke(obj, new Object[] {data, dis }); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} + +class FutureDAOImpl extends FutureDAO{ + + + public FutureDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS ) throws APIException, IOException { + super(trans, historyDAO); + setPs(this, readPS, "createPS"); + } + + + public void setPs(FutureDAOImpl FutureDAOObj, PSInfo psInfoObj, String methodName) { + Field nsDaoField; + try { + nsDaoField = CassDAOImpl.class.getDeclaredField(methodName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(FutureDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_HistoryDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_HistoryDAO.java new file mode 100644 index 00000000..78eb92e8 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_HistoryDAO.java @@ -0,0 +1,331 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.junit.Assert.assertTrue; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.nio.ByteBuffer; +import java.util.Date; +import java.util.List; +import java.util.UUID; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO.CRUD; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.dao.cass.HistoryDAO.Data; +import org.onap.aaf.auth.dao.AbsCassDAO; +import org.onap.aaf.auth.dao.CassDAOImpl; +import org.onap.aaf.auth.dao.Loader; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.misc.env.APIException; +import org.onap.aaf.misc.env.Env; +import org.onap.aaf.misc.env.LogTarget; +import org.onap.aaf.misc.env.TimeTaken; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.ResultSet; +import com.datastax.driver.core.Row; + +public class JU_HistoryDAO { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + } + + @Test + public void testInit() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + } + @Test + public void testNewInitedData() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + HistoryDAO.Data data = daoObj.newInitedData(); + assertTrue( Integer.toString(((new Date()).getYear())+1900).equalsIgnoreCase(Integer.toString(data.yr_mon).substring(0,4)) ); + } + + @Test + public void testCreateBatch() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + StringBuilder sb = new StringBuilder(); + HistoryDAO.Data data = new HistoryDAO.Data(); + daoObj.createBatch(sb, data); + assertTrue(sb.toString().contains("INSERT INTO history")); + } + + @Test + public void testReadByYYYYMM() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + AbsCassDAO.PSInfo psInfoObj = Mockito.mock(PSInfo.class); + setAbsCassDAO(daoObj, psInfoObj, "readByYRMN"); + + ResultSet rs = Mockito.mock(ResultSet.class); + Result rs1 = new Result(rs,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "yr_mon", 201905); + + Result> retVal = daoObj.readByYYYYMM(trans, 201905); + assertTrue(retVal.status !=1); + + rs1 = new Result(rs,1,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "yr_mon", 201905); + retVal = daoObj.readByYYYYMM(trans, 201905); + assertTrue(retVal.status !=0); + } + + @Test + public void testReadByUser() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + AbsCassDAO.PSInfo psInfoObj = Mockito.mock(PSInfo.class); + setAbsCassDAO(daoObj, psInfoObj, "readByUser"); + + ResultSet rs = Mockito.mock(ResultSet.class); + Result rs1 = new Result(rs,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "user", "test"); + + Result> retVal = daoObj.readByUser(trans, "test", 201905); + assertTrue(retVal.status !=1); + + rs1 = new Result(rs,1,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "user", "test"); + retVal = daoObj.readByUser(trans,"test", 201905); + assertTrue(retVal.status !=0); + + retVal = daoObj.readByUser(trans,"test"); + assertTrue(retVal.status !=0); + } + + @Test + public void testReadBySubject() { + HistoryDAO daoObj = new HistoryDAO(trans, cluster, "test"); + AbsCassDAO.PSInfo psInfoObj = Mockito.mock(PSInfo.class); + setAbsCassDAO(daoObj, psInfoObj, "readBySubject"); + + ResultSet rs = Mockito.mock(ResultSet.class); + Result rs1 = new Result(rs,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "subject", "test", "test"); + + Result> retVal = daoObj.readBySubject(trans, "test", "test", 201905); + assertTrue(retVal.status !=1); + + rs1 = new Result(rs,1,"test",new String[0]); + Mockito.doReturn(rs1).when(psInfoObj).exec(trans, "subject", "test", "test"); + retVal = daoObj.readBySubject(trans,"test", "test", 201905); + assertTrue(retVal.status !=0); + + retVal = daoObj.readBySubject(trans,"test", "test"); + assertTrue(retVal.status !=0); + } + + public void setAbsCassDAO(HistoryDAO HistoryDAOObj, PSInfo psInfoObj, String fieldName) { + Field nsDaoField; + try { + nsDaoField = HistoryDAO.class.getDeclaredField(fieldName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(HistoryDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + @Test + public void testSecondConstructor() { + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + + HistoryDAO daoObj = new HistoryDAO(trans, historyDAO); + + } + + @Test + public void testHistoryLoader(){ + Class innerClass = null; + Class[] innerClassArr = HistoryDAO.class.getDeclaredClasses(); + for(Class indCls:innerClassArr) { + if(indCls.getName().contains("HistLoader")) { + innerClass = indCls; + break; + } + } + + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + + try { + Object obj = constructor.newInstance(1); + Method innnerClassMtd; + + HistoryDAO.Data data = new HistoryDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {HistoryDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {HistoryDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} }); +// + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {HistoryDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testYYYYMM(){ + Class innerClass = null; + Class[] innerClassArr = HistoryDAO.class.getDeclaredClasses(); + for(Class indCls:innerClassArr) { + if(indCls.getName().contains("YYYYMM")) { + innerClass = indCls; + break; + } + } + + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + int yyyymm[] = new int[2]; + try { + Object obj = constructor.newInstance(new HistoryDAO(trans, cluster, "test"), yyyymm); + Method innnerClassMtd; + + HistoryDAO.Data data = new HistoryDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("ok", new Class[] {HistoryDAO.Data.class}); + innnerClassMtd.invoke(obj, new Object[] {data}); + + data.yr_mon=201904; + innnerClassMtd.invoke(obj, new Object[] {data}); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} + +class HistoryDAOImpl extends HistoryDAO{ + + + public HistoryDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS ) throws APIException, IOException { + super(trans, historyDAO); + setPs(this, readPS, "createPS"); + } + + public void setPs(HistoryDAOImpl HistoryDAOObj, PSInfo psInfoObj, String methodName) { + Field nsDaoField; + try { + nsDaoField = CassDAOImpl.class.getDeclaredField(methodName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(HistoryDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java new file mode 100644 index 00000000..bfc370f4 --- /dev/null +++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java @@ -0,0 +1,319 @@ +/** + * ============LICENSE_START==================================================== + * org.onap.aaf + * =========================================================================== + * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved. + * =========================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END==================================================== + * + */ + +package org.onap.aaf.auth.dao.cass; + +import static org.junit.Assert.assertTrue; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.nio.ByteBuffer; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.TreeSet; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.aaf.auth.dao.AbsCassDAO; +import org.onap.aaf.auth.dao.AbsCassDAO.CRUD; +import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo; +import org.onap.aaf.auth.dao.CassDAOImpl; +import org.onap.aaf.auth.env.AuthzTrans; +import org.onap.aaf.auth.layer.Result; +import org.onap.aaf.misc.env.APIException; + +import com.datastax.driver.core.Cluster; +import com.datastax.driver.core.Row; + +public class JU_LocateDAO { + + @Mock + AuthzTrans trans; + @Mock + Cluster cluster; + + @Before + public void setUp() throws APIException, IOException { + initMocks(this); + } + + @Test + public void testInit() { + try { + LocateDAO daoObj = new LocateDAO(trans, cluster, "test"); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + @Test + public void testReadByStartAndTarget() { + LocateDAO daoObj = null; + try { + daoObj = new LocateDAO(trans, cluster, "test"); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PSInfo psObj = Mockito.mock(PSInfo.class); + setPsByStartAndTarget(daoObj, psObj, "psName"); + + Result> rs1 = new Result>(null,0,"test",new String[0]); + Mockito.doReturn(rs1).when(psObj).read(trans, "LocateDAO READ", new Object[]{"test"}); + + daoObj.readByName(trans, "test"); + } + + + public void setPsByStartAndTarget(LocateDAO LocateDAOObj, PSInfo psInfoObj, String fieldName) { + Field nsDaoField; + try { + nsDaoField = LocateDAO.class.getDeclaredField(fieldName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(LocateDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testWasMOdified() { + + LocateDAO.Data data = new LocateDAO.Data(); + + HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class); + + LocateDAO daoObj = null; + try { + daoObj = new LocateDAO(trans, historyDAO ); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"}); + + + } + + @Test + public void testSecondConstructor() { + AbsCassDAO historyDAO = Mockito.mock(AbsCassDAO.class); + + try { + LocateDAO daoObj = new LocateDAO(trans, historyDAO); + } catch (APIException | IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + + @Test + public void testLocateLoader(){ + Class innerClass = null; + Class[] innerClassArr = LocateDAO.class.getDeclaredClasses(); + for(Class indCls:innerClassArr) { + if(indCls.getName().contains("LocateLoader")) { + innerClass = indCls; + break; + } + } + + Constructor constructor = innerClass.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + + try { + + Object obj = constructor.newInstance(1); + Method innnerClassMtd; + + LocateDAO.Data data = new LocateDAO.Data(); + Row row = Mockito.mock(Row.class); + ByteBuffer bbObj = ByteBuffer.allocateDirect(10); + bbObj.limit(7); + bbObj.put(0, new Byte("0")); + bbObj.put(1, new Byte("1")); + bbObj.put(2, new Byte("2")); + Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1); + + innnerClassMtd = innerClass.getMethod("load", new Class[] {LocateDAO.Data.class, Row.class}); + innnerClassMtd.invoke(obj, new Object[] {data, row}); + + innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {LocateDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 0, new Object[] {"test","test","test"} }); + + innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {LocateDAO.Data.class, Integer.TYPE, Object[].class }); + innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} }); + + DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_LocateDAOTest.java")); + innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {LocateDAO.Data.class, DataOutputStream.class }); + innnerClassMtd.invoke(obj, new Object[] {data, dos }); + + DataInputStream dis = new DataInputStream(new FileInputStream("JU_LocateDAOTest.java")); + innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {LocateDAO.Data.class, DataInputStream.class }); + innnerClassMtd.invoke(obj, new Object[] {data, dis }); + + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testData(){ + LocateDAO.Data data = new LocateDAO.Data(); + data.name="name"; + data.hostname="hostname"; + try { + data.bytify(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + data.subprotocol(true); + + Set subProt = new HashSet(); + Field protField; + try { + protField = LocateDAO.Data.class.getDeclaredField("subprotocol"); + + protField.setAccessible(true); + + protField.set(data, subProt); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + data.subprotocol(true); + subProt = new TreeSet(); + subProt.add("test"); + try { + protField = LocateDAO.Data.class.getDeclaredField("subprotocol"); + + protField.setAccessible(true); + + protField.set(data, subProt); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + data.subprotocol(true); + data.subprotocol(false); + + LocateDAO.Data newDate = data.copy(); + assertTrue(data.name.equals(newDate.name)); + } + +} + +class LocateDAOImpl extends LocateDAO{ + + + public LocateDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS ) throws APIException, IOException { + super(trans, historyDAO); + setPs(this, readPS, "createPS"); + } + + + public void setPs(LocateDAOImpl LocateDAOObj, PSInfo psInfoObj, String methodName) { + Field nsDaoField; + try { + nsDaoField = CassDAOImpl.class.getDeclaredField(methodName); + + nsDaoField.setAccessible(true); + // remove final modifier from field + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); +// modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL); + + nsDaoField.set(LocateDAOObj, psInfoObj); + } catch (NoSuchFieldException | SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} -- cgit 1.2.3-korg