Include impacted changes for APPC-346,APPC-348

Issue-ID: APPC-347
Change-Id: I399bc2a1e0dfd481e103032a373bb80fce5baf41
Signed-off-by: Anand <ac204h@att.com>

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);
+
+        }
+
+
+    }*/
+}