Added select query db assertion, updated readme, added report folder …

…to git ignor

.gitignore

@@ -27,3 +27,4 @@ hs_err_pid*
 .idea
 target
 test-output
+Report

README.md

@@ -252,6 +252,14 @@ Auth token can be passed from maven command line as well as config file. If the
     #  | <column name> |
     Then Expect 'testData/DbOps/scenario1/output/' with ignore columns
       | user_id |
+      
+    #Execute select query to validate data exist in DB
+    #Then validate data exist for select query "<sql query>"
+    Then validate data exist for select query "select * from users where name = 'abhishek kadavil'"
+
+    #Execute select query to validate data does not exist in DB
+    #Then validate data does not exist for select query "<sql query>"
+    Then validate data does not exist for select query "select * from users where name = 'abhishek kadavil1'"
 
 ```
 

src/test/java/testSuit/stepDef/DBOpsStepDef.java

@@ -6,6 +6,7 @@
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
 import org.dbunit.database.DatabaseDataSourceConnection;
 import org.dbunit.dataset.CachedDataSet;
 import org.dbunit.dataset.IDataSet;
@@ -16,8 +17,10 @@
 
 import javax.sql.DataSource;
 import java.net.URL;
+import java.sql.ResultSet;
 import java.util.List;
 
+@Slf4j
 public class DBOpsStepDef {
 
     private DataSource dataSource = DataSourceFactory.getDataSource();
@@ -100,4 +103,16 @@ public void addDBValidationToReport(IDataSet expectDataSet, IDataSet actualDataS
             ReporterFactory.getInstance().getExtentTest().log(Status.INFO, MarkupHelper.createCodeBlock(sb.toString()));
         }
     }
+
+    @SneakyThrows
+    @Then("validate data exist for select query {string}")
+    public void validate_data_exist_for_select_query_string(String sqlStatement) {
+        dbOpsUtil.executeSelQueryForDataExist(dataSource, sqlStatement);
+    }
+
+    @SneakyThrows
+    @Then("validate data does not exist for select query {string}")
+    public void validate_data_does_not_exist_for_select_query_string(String sqlStatement) {
+        dbOpsUtil.executeSelQueryForDataNotExist(dataSource, sqlStatement);
+    }
 }

src/test/java/testSuit/utils/DbOpsUtil.java

@@ -1,8 +1,11 @@
 package testSuit.utils;
 
+import com.aventstack.extentreports.Status;
+import com.aventstack.extentreports.markuputils.MarkupHelper;
 import com.github.springtestdbunit.assertion.DatabaseAssertionMode;
 import io.cucumber.guice.ScenarioScoped;
 import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
 import org.dbunit.database.DatabaseConfig;
 import org.dbunit.database.DatabaseDataSourceConnection;
 import org.dbunit.database.IDatabaseConnection;
@@ -12,26 +15,38 @@
 import org.dbunit.dataset.filter.IColumnFilter;
 import org.dbunit.operation.DatabaseOperation;
 import org.dbunit.operation.TransactionOperation;
+import org.testng.Assert;
+import org.xmlunit.util.Convert;
 
 import javax.sql.DataSource;
 import java.net.URL;
 import java.sql.Connection;
+import java.sql.ResultSet;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;
 
+@Slf4j
 @ScenarioScoped
 public class DbOpsUtil {
 
+    IDatabaseConnection dataSourceConnection = null;
+    Connection connection = null;
+    Statement statement = null;
+    ResultSet resultSet = null;
+
+    IDatabaseConnection iDatabaseConnection;
+    DatabaseOperation databaseOperation;
+
     @SneakyThrows
     public IDataSet csvToDataSet(URL path) {
         return new CsvURLDataSet(path);
     }
 
     @SneakyThrows
     public void insertDataSetIntoDBByDeletingOtherData(DataSource dataSource, IDataSet idataSet) {
-        IDatabaseConnection iDatabaseConnection = new DatabaseDataSourceConnection(dataSource);
-        DatabaseOperation databaseOperation = new TransactionOperation(DatabaseOperation.CLEAN_INSERT);
+        iDatabaseConnection = new DatabaseDataSourceConnection(dataSource);
+        databaseOperation = new TransactionOperation(DatabaseOperation.CLEAN_INSERT);
         iDatabaseConnection
                 .getConfig()
                 .setProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, true);
@@ -41,8 +56,8 @@ public void insertDataSetIntoDBByDeletingOtherData(DataSource dataSource, IDataS
 
     @SneakyThrows
     public void insertDataSetIntoDB(DataSource dataSource, IDataSet idataSet) {
-        IDatabaseConnection iDatabaseConnection = new DatabaseDataSourceConnection(dataSource);
-        DatabaseOperation databaseOperation = new TransactionOperation(DatabaseOperation.INSERT);
+        iDatabaseConnection = new DatabaseDataSourceConnection(dataSource);
+        databaseOperation = new TransactionOperation(DatabaseOperation.INSERT);
         iDatabaseConnection
                 .getConfig()
                 .setProperty(DatabaseConfig.FEATURE_ALLOW_EMPTY_FIELDS, true);
@@ -55,7 +70,7 @@ public void compareDataSets(IDataSet expectDataSet, IDataSet actualDataSet, Stri
 
         List<IColumnFilter> columnFilters = new ArrayList<>();
         DefaultColumnFilter columnFilter = new DefaultColumnFilter();
-        for(int i=0;i<cols.length;i++){
+        for (int i = 0; i < cols.length; i++) {
             columnFilter.excludeColumn(cols[i]);
         }
         columnFilters.add(columnFilter);
@@ -74,15 +89,125 @@ public void compareDataSets(IDataSet expectDataSet, IDataSet actualDataSet) {
     }
 
     @SneakyThrows
-    public void executeStatement(DataSource dataSource, String sqlStatement)
-    {
-        IDatabaseConnection dataSourceConnection = new DatabaseDataSourceConnection(dataSource);
-        Connection connection = dataSourceConnection.getConnection();
-        Statement statement = connection.createStatement();
-
-        statement.execute(sqlStatement);
-        statement.close();
-        connection.close();
-        dataSourceConnection.close();
+    public void executeStatement(DataSource dataSource, String sqlStatement) {
+        try {
+            dataSourceConnection = new DatabaseDataSourceConnection(dataSource);
+            connection = dataSourceConnection.getConnection();
+            statement = connection.createStatement();
+            statement.execute(sqlStatement);
+        } catch (Exception e) {
+            log.info("An error occurred while processing results in executeStatement");
+            log.info(e.toString());
+            throw e;
+        } finally {
+            assert statement != null;
+            statement.close();
+            connection.close();
+            dataSourceConnection.close();
+        }
+    }
+
+    @SneakyThrows
+    public void executeSelQueryForDataExist(DataSource dataSource, String sqlStatement) {
+        try {
+            dataSourceConnection = new DatabaseDataSourceConnection(dataSource);
+            connection = dataSourceConnection.getConnection();
+            statement = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
+            resultSet = statement.executeQuery(sqlStatement);
+
+            if (resultSet.next()) {
+
+                ReporterFactory.getInstance().getExtentTest().log(Status.PASS, "Query returned values");
+
+                // Move the cursor back to the start
+                resultSet.beforeFirst();
+
+                // Retrieve column count
+                int columnCount = resultSet.getMetaData().getColumnCount();
+                StringBuilder columnValues = new StringBuilder();
+
+                // Print column names
+                for (int i = 1; i <= columnCount; i++) {
+                    columnValues.append(resultSet.getMetaData().getColumnName(i)).append("\t | \t");
+                }
+                ReporterFactory.getInstance().getExtentTest().log(Status.INFO, "Column values:- | " + columnValues);
+
+                // Print rows
+                StringBuilder rowValues = new StringBuilder();
+                while (resultSet.next()) {
+                    for (int i = 1; i <= columnCount; i++) {
+                        rowValues.append(resultSet.getString(i) + "\t | \t");
+                    }
+                    ReporterFactory.getInstance().getExtentTest().log(Status.INFO, "Row values:- | " + rowValues + "\n");
+                    rowValues.setLength(0);
+                }
+
+            } else {
+                Assert.fail("Query does not return any values");
+            }
+
+        } catch (Exception e) {
+            log.info("An error occurred while processing results in executeSelQuery");
+            log.info(e.toString());
+            throw e;
+        } finally {
+            assert statement != null;
+            statement.close();
+            connection.close();
+            dataSourceConnection.close();
+        }
+    }
+
+    @SneakyThrows
+    public void executeSelQueryForDataNotExist(DataSource dataSource, String sqlStatement) {
+        try {
+            dataSourceConnection = new DatabaseDataSourceConnection(dataSource);
+            connection = dataSourceConnection.getConnection();
+            statement = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
+            resultSet = statement.executeQuery(sqlStatement);
+
+            if (resultSet.next()) {
+
+                // Move the cursor back to the start
+                resultSet.beforeFirst();
+
+                // Retrieve column count
+                int columnCount = resultSet.getMetaData().getColumnCount();
+                StringBuilder columnValues = new StringBuilder();
+
+                // Print column names
+                for (int i = 1; i <= columnCount; i++) {
+                    columnValues.append(resultSet.getMetaData().getColumnName(i)).append("\t | \t");
+                }
+                ReporterFactory.getInstance().getExtentTest().log(Status.INFO, "Column values:- | " + columnValues);
+
+                // Print rows
+                StringBuilder rowValues = new StringBuilder();
+                while (resultSet.next()) {
+                    for (int i = 1; i <= columnCount; i++) {
+                        rowValues.append(resultSet.getString(i) + "\t | \t");
+                    }
+                    ReporterFactory.getInstance().getExtentTest().log(Status.INFO, "Row values:- | " + rowValues + "\n");
+                    rowValues.setLength(0);
+                }
+                Assert.fail("Query returned values");
+
+            } else {
+                resultSet.last();
+                ReporterFactory.getInstance().getExtentTest().log(Status.PASS, "Query returned " + resultSet.getRow() + " rows");
+            }
+
+        } catch (Exception e) {
+            log.info("An error occurred while processing results in executeSelQueryForDataNotExist");
+            log.info(e.toString());
+            throw e;
+        } finally {
+            assert statement != null;
+            statement.close();
+            connection.close();
+            dataSourceConnection.close();
+        }
     }
+
+
 }

src/test/resources/features/dbFeatures/DbOps.feature

@@ -2,27 +2,43 @@ Feature: DB operations
   DB operation steps
 
   @DbOps01 @DbOpsAll
-  Scenario: update DB with CSV and validate - SUCCESS - with ignore columns
+  Scenario: 01 update DB with CSV and validate - SUCCESS - with ignore columns
     Given execute statement "delete from users"
     Given db is updated with "testData/DbOps/scenario1/input/"
     Then Expect 'testData/DbOps/scenario1/output/' with ignore columns
       | user_id |
 
   @DbOps02 @DbOpsAll
-  Scenario: update DB with CSV and validate - ERROR - with ignore columns
+  Scenario: 02 update DB with CSV and validate - ERROR - with ignore columns
     Given execute statement "delete from users"
     Given db is updated with "testData/DbOps/scenario2/input/"
     Then Expect 'testData/DbOps/scenario2/output/' with ignore columns
       | user_id |
 
   @DbOps03 @DbOpsAll
-  Scenario: update DB with CSV and validate - SUCCESS - without ignore columns
+  Scenario: 03 update DB with CSV and validate - SUCCESS - without ignore columns
     Given execute statement "delete from users"
     Given db is updated with "testData/DbOps/scenario3/input/"
     Then Expect 'testData/DbOps/scenario3/output/'
 
   @DbOps04 @DbOpsAll
-  Scenario: update DB with CSV and validate - ERROR - without ignore columns
+  Scenario: 04 update DB with CSV and validate - ERROR - without ignore columns
     Given execute statement "delete from users"
     Given db is updated with "testData/DbOps/scenario4/input/"
-    Then Expect 'testData/DbOps/scenario4/output/'
+    Then Expect 'testData/DbOps/scenario4/output/'
+
+  @DbOps05 @DBParallel @DbOpsAll
+  Scenario: 05 Use select query to validate DB table - return 1 row - Success
+    Then validate data exist for select query "select * from users where name = 'abhishek kadavil'"
+
+  @DbOps06 @DBParallel @DbOpsAll
+  Scenario: 06 Use select query to validate DB table - return 0 row - Fail
+    Then validate data exist for select query "select * from users where name = 'abhishek kadavil1'"
+
+  @DbOps07 @DBParallel @DbOpsAll1
+  Scenario: 07 Use select query to validate DB table - return 0 row - Success
+    Then validate data does not exist for select query "select * from users where name = 'abhishek kadavil1'"
+
+  @DbOps08 @DBParallel @DbOpsAll1
+  Scenario: 08 Use select query to validate DB table - return 1 row - Success
+    Then validate data does not exist for select query "select * from users where name = 'abhishek kadavil'"