diff options
author | 2018-01-04 19:35:51 -0500 | |
---|---|---|
committer | 2018-01-08 22:09:50 +0000 | |
commit | 36bcd566167f2f91c0e8e7a304fce5f6bc150776 (patch) | |
tree | 7ba7acfee7e520da83a2b6286ea464285bc8cf67 /appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java | |
parent | 38d293d605b42f88c9c82319ba848b4b81e45b64 (diff) |
Include impacted changes for APPC-346,APPC-348
Issue-ID: APPC-347
Change-Id: I399bc2a1e0dfd481e103032a373bb80fce5baf41
Signed-off-by: Anand <ac204h@att.com>
Diffstat (limited to 'appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java')
-rw-r--r-- | appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java/org/onap/appc/transactionrecorder/impl/TransactionRecorderImplTest.java | 466 |
1 files changed, 466 insertions, 0 deletions
diff --git a/appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java/org/onap/appc/transactionrecorder/impl/TransactionRecorderImplTest.java b/appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java/org/onap/appc/transactionrecorder/impl/TransactionRecorderImplTest.java new file mode 100644 index 000000000..738a8a638 --- /dev/null +++ b/appc-dispatcher/appc-dispatcher-common/transaction-recorder/src/test/java/org/onap/appc/transactionrecorder/impl/TransactionRecorderImplTest.java @@ -0,0 +1,466 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP : APPC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Copyright (C) 2017 Amdocs + * ============================================================================= + * 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. + * + * ECOMP is a trademark and service mark of AT&T Intellectual Property. + * ============LICENSE_END========================================================= + */ + +package org.onap.appc.transactionrecorder.impl; + +import com.sun.rowset.CachedRowSetImpl; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; + +import org.onap.appc.dao.util.dbcp.DBConnectionPool; +import org.onap.appc.dao.util.helper.DBHelper; +import org.onap.appc.domainmodel.lcm.Flags; +import org.onap.appc.domainmodel.lcm.RequestStatus; +import org.onap.appc.domainmodel.lcm.TransactionRecord; +import org.onap.appc.domainmodel.lcm.VNFOperation; +import org.onap.appc.exceptions.APPCException; +import org.onap.appc.transactionrecorder.objects.TransactionConstants; +import org.onap.ccsdk.sli.core.dblib.DbLibService; + +import javax.sql.rowset.CachedRowSet; +import java.sql.*; +import java.time.Instant; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +import static org.mockito.Matchers.*; + +/** + * Test class for TransactionRecorder + */ +public class TransactionRecorderImplTest { + + private String dbUrl = "jdbc:h2:mem:test;MODE=MYSQL;DB_CLOSE_DELAY=-1"; + private String username = "sa"; + private String password = "sa"; + private String driver = "org.h2.Driver"; + + private TransactionRecorderImpl transactionRecorderImpl; + private DbLibService dbLibService; + + private DBConnectionPool dbConnectionPool; + + + /** + * Ideally JUnit should grab the SQL to create the transaction table from the same source used in deployments; + * however, at the time of writing this that was not possible. Should it become possible in the future please + * update this JUnit test to use the deployment source. + * <p> + * Please ensure this table create script is identical to the source script used in a deployment. + */ + private String TRANSACTION_CREATE_TABLE = "CREATE TABLE TRANSACTIONS (" + + " TRANSACTION_ID VARCHAR(75) NOT NULL PRIMARY KEY," + + " ORIGIN_TIMESTAMP DATETIME(3) NOT NULL," + + " REQUEST_ID VARCHAR(256) NOT NULL," + + " SUBREQUEST_ID VARCHAR(256) DEFAULT NULL," + + " ORIGINATOR_ID VARCHAR(256) DEFAULT NULL," + + " START_TIME DATETIME(3) NOT NULL," + + " END_TIME DATETIME(3) DEFAULT NULL," + + " TARGET_ID VARCHAR(256) NOT NULL," + + " TARGET_TYPE VARCHAR(256) DEFAULT NULL," + + " OPERATION VARCHAR(256) NOT NULL," + + " RESULT_CODE INT(11) DEFAULT NULL," + + " DESCRIPTION TEXT," + + " STATE VARCHAR(50) NOT NULL," + + " SERVICE_INSTANCE_ID VARCHAR(256) DEFAULT NULL," + + " VNFC_NAME VARCHAR(256) DEFAULT NULL," + + " VSERVER_ID VARCHAR(256) DEFAULT NULL," + + " VF_MODULE_ID VARCHAR(256) DEFAULT NULL," + + " MODE VARCHAR(50) NOT NULL," + + ")"; + private String TRANSACTION_DROP_TABLE = "DROP TABLE IF EXISTS TRANSACTIONS"; + + @Before + public void setUp() throws Exception { + transactionRecorderImpl = new TransactionRecorderImpl(); + transactionRecorderImpl.setAppcInstanceId("123"); + dbLibService = Mockito.mock(DbLibService.class); + transactionRecorderImpl.setDbLibService(dbLibService); + dbConnectionPool = new DBConnectionPool(dbUrl, username, password, driver); + executeUpdate(TRANSACTION_CREATE_TABLE); + + } + + + @After + public void shutdown() { + if (dbConnectionPool != null) { + executeUpdate(TRANSACTION_DROP_TABLE); + dbConnectionPool.shutdown(); + } + } + + private void executeUpdate(String updateSQL) { + Connection connection = null; + Statement stmt = null; + try { + connection = dbConnectionPool.getConnection(); + stmt = connection.createStatement(); + stmt.executeUpdate(updateSQL); + } catch (SQLException e) { + throw new RuntimeException(e); + } finally { + DBHelper.close(null, stmt, connection); + } + } + + /** + * Verify the transactionRecorderImpl.sore() store the TransactionRecord correctly in the database. + */ + @Test + public void testStore() throws Exception { + + TransactionRecord input = prepareTransactionsInput(); + Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + testStoreInMemory(invocation.getArguments())); + transactionRecorderImpl.store(input); + + } + + @Test + public void testGetInProgressRequests() throws SQLException, APPCException { + TransactionRecord record1 = prepareTransactionsInput(); + insertRecord(record1); + TransactionRecord input = prepareTransactionsInput(); + input.setStartTime(Instant.now()); + Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + inMemoryExecutionWithResultSet(invocation.getArguments())); + Assert.assertEquals(1, transactionRecorderImpl.getInProgressRequests(input).size()); + + } + + @Test + public void testIsTransactionDuplicate() throws SQLException, APPCException { + TransactionRecord input = prepareTransactionsInput(); + Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + inMemoryExecutionWithResultSet(invocation.getArguments())); + Assert.assertFalse(transactionRecorderImpl.isTransactionDuplicate(input)); + + } + + @Test + public void testGetInProgressRequestsCount() throws SQLException, APPCException { + TransactionRecord input = prepareTransactionsInput(); + Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + inMemoryExecutionWithResultSet(invocation.getArguments())); + Assert.assertEquals(0, transactionRecorderImpl.getInProgressRequestsCount().intValue()); + } + + @Test + public void testUpdate() throws APPCException, SQLException { + TransactionRecord input = prepareTransactionsInput(); + insertRecord(input); + Map<TransactionConstants.TRANSACTION_ATTRIBUTES, String> updateColumns = new HashMap<>(); + updateColumns.put(TransactionConstants.TRANSACTION_ATTRIBUTES.TARGET_TYPE, "Firewall"); + Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + testUpdateInMemory(invocation.getArguments())); + transactionRecorderImpl.update(input.getTransactionId(), updateColumns); + } + + @Test + public void testMarkTransactionsAborted() throws SQLException { + TransactionRecord input = prepareTransactionsInput(); + insertRecord(input); + Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation -> + testMarkAbortedInMemory(invocation.getArguments())); + transactionRecorderImpl.markTransactionsAborted("123~"); + } + + private ResultSet inMemoryExecutionWithResultSet(Object[] obj) throws Exception { + String query = (String) obj[0]; + ArrayList<String> args = (ArrayList<String>) obj[1]; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(query); + for (int i = 1; i <= args.size(); i++) { + ps.setString(i, args.get(i - 1)); + } + CachedRowSet rowSet = new CachedRowSetImpl(); + rowSet.populate(ps.executeQuery()); + return rowSet; + } + + private boolean testMarkAbortedInMemory(Object[] obj) throws Exception { + String query = (String) obj[0]; + ArrayList<String> args = (ArrayList<String>) obj[1]; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(query); + for (int i = 1; i <= args.size(); i++) { + ps.setString(i, args.get(i - 1)); + } + ps.execute(); + return isTransactionAborted(); + } + + private boolean isTransactionAborted() throws Exception { + String query = "SELECT COUNT(*) FROM TRANSACTIONS WHERE STATE = ?"; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(query); + ps.setString(1, RequestStatus.ABORTED.toString()); + ResultSet rs = ps.executeQuery(); + while (rs.next()) { + int value = rs.getInt(1); + if (value == 1) { + System.out.println("Non terminal Transactions are aborted"); + return true; + } + } + throw new Exception("Transactions are not aborted"); + } + + private boolean testUpdateInMemory(Object[] obj) throws Exception { + String query = (String) obj[0]; + ArrayList<String> args = (ArrayList<String>) obj[1]; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(query); + for (int i = 1; i <= args.size(); i++) { + ps.setString(i, args.get(i - 1)); + } + ps.execute(); + String updatedValue = checkIfValueIsUpdated(args.get(1)); + System.out.println("updated Value is " + updatedValue); + if (updatedValue.equals("Firewall")) { + return true; + } + throw new Exception("Not Updated"); + } + + private boolean testStoreInMemory(Object[] obj) throws Exception { + String query = (String) obj[0]; + ArrayList<String> args = (ArrayList<String>) obj[1]; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(query); + for (int i = 1; i <= args.size(); i++) { + ps.setString(i, args.get(i - 1)); + } + ps.execute(); + if (checkIfRowIsPresent(args.get(0))) { + return true; + } + throw new Exception("Failed to update"); + } + + private TransactionRecord prepareTransactionsInput() { + TransactionRecord input = new TransactionRecord(); + input.setTransactionId(UUID.randomUUID().toString()); + input.setOriginTimestamp(Instant.parse("2017-09-11T00:00:01.00Z")); + input.setRequestId("REQUEST_ID"); + input.setSubRequestId("SUB_REQUEST_ID"); + input.setOriginatorId("ORIGINATOR_ID"); + input.setStartTime(Instant.parse("2017-09-11T00:00:02.00Z")); + input.setTargetId("TARGET_ID"); + input.setTargetType("TARGET_TYPE"); + input.setServiceInstanceId("SERVICE_INSTANCE_ID"); + input.setOperation(VNFOperation.ActionStatus); + input.setResultCode(200); + input.setRequestState(RequestStatus.ACCEPTED); + input.setDescription("DESCRIPTION"); + input.setMode(Flags.Mode.EXCLUSIVE); + return input; + } + + private void insertRecord(TransactionRecord input) throws SQLException { + final String STORE_DATE_QUERY = TransactionConstants.INSERT_INTO + TransactionConstants.TRANSACTIONS + + " values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement(STORE_DATE_QUERY); + ArrayList<String> args = prepareArguments(input); + args.remove(0); + args.add(0, "123~" + input.getTransactionId()); + for (int i = 1; i <= 18; i++) { + ps.setString(i, args.get(i - 1)); + } + ps.execute(); + if (checkIfRowIsPresent(args.get(0))) { + System.out.println("RECORD INSERTED " + args.get(0)); + } + + } + + private ArrayList<String> prepareArguments(TransactionRecord input) { + ArrayList<String> arguments = new ArrayList<>(); + arguments.add(input.getTransactionId()); + arguments.add(dateToStringConverterMillis(input.getOriginTimestamp())); + arguments.add(input.getRequestId()); + arguments.add(input.getSubRequestId()); + arguments.add(input.getOriginatorId()); + arguments.add(dateToStringConverterMillis(input.getStartTime())); + arguments.add(dateToStringConverterMillis(input.getEndTime())); + arguments.add(input.getTargetId()); + arguments.add(input.getTargetType()); + arguments.add(input.getOperation().name()); + arguments.add(String.valueOf(input.getResultCode())); + arguments.add(input.getDescription()); + arguments.add(input.getRequestState()); + arguments.add(input.getServiceInstanceId()); + arguments.add(input.getVnfcName()); + arguments.add(input.getVserverId()); + arguments.add(input.getVfModuleId()); + arguments.add(input.getMode()); + + return arguments; + } + + private static String dateToStringConverterMillis(Instant date) { + if (date == null) { + return null; + } + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS").withZone(ZoneOffset.UTC); + return formatter.format(date); + } + + private boolean checkIfRowIsPresent(String key) { + Connection con = null; + ResultSet rs = null; + PreparedStatement ps = null; + try { + con = dbConnectionPool.getConnection(); + ps = con.prepareStatement("SELECT COUNT(*) FROM TRANSACTIONS WHERE TRANSACTION_ID = ?"); + ps.setString(1, key); + rs = ps.executeQuery(); + while (rs.next()) { + int value = rs.getInt(1); + System.out.println("KEY checked is " + key + " COUNT RETURNED IS " + value); + if (value == 1) { + return true; + } + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + DBHelper.close(rs, ps, con); + } + return false; + } + + private String checkIfValueIsUpdated(String key) throws Exception { + Connection con = dbConnectionPool.getConnection(); + PreparedStatement ps = con.prepareStatement("SELECT TARGET_TYPE FROM TRANSACTIONS WHERE TRANSACTION_ID = ?"); + ps.setString(1, key); + ResultSet rs = ps.executeQuery(); + while (rs.next()) { + String value = rs.getString("TARGET_TYPE"); + return value; + } + throw new Exception("Value not found"); + } + + + /** + * Verify the transactionRecorderImpl. getRecords () can be fetch with each of the parameter combinations + * @throws Exception + *//* + @Test + public void test_api_getRecords() throws Exception { + + + final int requestId = 0; + final int subrequestId = 1; + final int originatorId = 2; + final int vnfId = 3; + final int requestStatus = 4; + + + String[][] trCreateMatrix = { + {"request1", "subrequestId1", "originatorId1", "vnfId1", RequestStatus.UNKNOWN.name()}, + {"request1", "subrequestId2", "originatorId1", "vnfId1", RequestStatus.RECEIVED.name()}, + {"request2", "subrequestId1", "originatorId1", "vnfId1", RequestStatus.ACCEPTED.name()}, + {"request2", "subrequestId2", "originatorId1", "vnfId1", RequestStatus.REJECTED.name()}, + {"request1", "subrequestId1", "originatorId1", "vnfId2", RequestStatus.SUCCESSFUL.name()}, + {"request1", "subrequestId2", "originatorId1", "vnfId2", RequestStatus.FAILED.name()}, + {"request2", "subrequestId1", "originatorId1", "vnfId2", RequestStatus.TIMEOUT.name()}, + {"request2", "subrequestId2", "originatorId1", "vnfId2", RequestStatus.ABORTED.name()}, + {"request1", "subrequestId1", "originatorId2", "vnfId1", RequestStatus.UNKNOWN.name()}, + {"request1", "subrequestId2", "originatorId2", "vnfId1", RequestStatus.RECEIVED.name()}, + {"request2", "subrequestId1", "originatorId2", "vnfId1", RequestStatus.ACCEPTED.name()}, + {"request2", "subrequestId2", "originatorId2", "vnfId1", RequestStatus.REJECTED.name()}, + {"request1", "subrequestId1", "originatorId2", "vnfId2", RequestStatus.SUCCESSFUL.name()}, + {"request1", "subrequestId2", "originatorId2", "vnfId2", RequestStatus.FAILED.name()}, + {"request2", "subrequestId1", "originatorId2", "vnfId2", RequestStatus.TIMEOUT.name()}, + {"request2", "subrequestId2", "originatorId2", "vnfId2", RequestStatus.ABORTED.name()}, + }; + + + TransactionRecord tr = new TransactionRecord(); + tr.setTimeStamp(Instant.parse("2017-09-11T00:00:01.00Z")); + tr.setStartTime(Instant.parse("2017-09-11T00:00:02.00Z")); + tr.setEndTime(Instant.parse("2017-09-11T00:00:03.00Z")); + tr.setTargetType("TARGET_TYPE"); + tr.setSubComponent("SUB_COMPONENT"); + tr.setOperation(VNFOperation.ActionStatus); + tr.setResultCode("RESULT_CODE"); + tr.setDescription("DESCRIPTION"); + + for (int row = 0; row < trCreateMatrix.length; row++) { + tr.setRequestID(trCreateMatrix[row][requestId]); + tr.setSubRequestID(trCreateMatrix[row][subrequestId]); + tr.setOriginatorId(trCreateMatrix[row][originatorId]); + tr.setTargetID(trCreateMatrix[row][vnfId]); + tr.setRequestStatus(RequestStatus.valueOf(trCreateMatrix[row][requestStatus])); + transactionRecorderImpl.store(tr); + } + + + String[][] trSearchMatrix = { + {"request1", null, null, "vnfId1"}, + {"request2", "subrequestId1", null, "vnfId1"}, + {"request1", null, "originatorId1", "vnfId1"}, + {"request2", "subrequestId2", "originatorId1", "vnfId1"}, + }; + + + for (int i = 0; i < trSearchMatrix.length; i++) { + final int row = i; + List<RequestStatus> actualList = transactionRecorderImpl + .getRecords(trSearchMatrix[row][requestId], trSearchMatrix[row][subrequestId], + trSearchMatrix[row][originatorId], trSearchMatrix[row][vnfId]) + .stream() + .sorted() + .collect(Collectors.toList()); + + List<RequestStatus> expectedList = Arrays.stream(trCreateMatrix) + .filter(entry -> entry[requestId].equals(trSearchMatrix[row][requestId])) + .filter(entry -> trSearchMatrix[row][subrequestId] == null || entry[subrequestId].equals + (trSearchMatrix[row][subrequestId])) + .filter(entry -> trSearchMatrix[row][originatorId] == null || entry[originatorId].equals + (trSearchMatrix[row][originatorId])) + .filter(entry -> entry[vnfId].equals(trSearchMatrix[row][vnfId])) + .map(entry -> RequestStatus.valueOf(entry[requestStatus])) + .sorted() + .collect(Collectors.toList()); + System.out.println(expectedList); + System.out.println(actualList); + Assert.assertEquals("Unexpected results: ", expectedList, actualList); + + } + + + }*/ +} |