Skip to content

Commit

Permalink
Feat: refactored unit test cases (#57)
Browse files Browse the repository at this point in the history 
* resolved: refactored unit test cases
  • Loading branch information
@tharun0064
tharun0064 authored Jan 22, 2025
1 parent 915a2e5 commit 090797b
Show file tree
Hide file tree
Showing 7 changed files with 142 additions and 209 deletions.
11 changes: 5 additions & 6 deletions src/query-performance-monitoring/performance-metrics/blocking_sessions.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,27 +14,26 @@ import (
"github.com/newrelic/nri-postgresql/src/query-performance-monitoring/datamodels"
)

func PopulateBlockingMetrics(conn *performancedbconnection.PGSQLConnection, pgIntegration *integration.Integration, gv *globalvariables.GlobalVariables) error {
func PopulateBlockingMetrics(conn *performancedbconnection.PGSQLConnection, pgIntegration *integration.Integration, gv *globalvariables.GlobalVariables) {
isEligible, enableCheckError := validations.CheckBlockingSessionMetricsFetchEligibility(conn, gv.Version)
if enableCheckError != nil {
log.Error("Error executing query: %v in PopulateBlockingMetrics", enableCheckError)
return commonutils.ErrUnExpectedError
return
}
if !isEligible {
log.Debug("Extension 'pg_stat_statements' is not enabled or unsupported version.")
return commonutils.ErrNotEligible
return
}
blockingQueriesMetricsList, blockQueryFetchErr := GetBlockingMetrics(conn, gv)
if blockQueryFetchErr != nil {
log.Error("Error fetching Blocking queries: %v", blockQueryFetchErr)
return commonutils.ErrUnExpectedError
return
}
if len(blockingQueriesMetricsList) == 0 {
log.Debug("No Blocking queries found.")
return nil
return
}
commonutils.IngestMetric(blockingQueriesMetricsList, "PostgresBlockingSessions", pgIntegration, gv)
return nil
}

func GetBlockingMetrics(conn *performancedbconnection.PGSQLConnection, gv *globalvariables.GlobalVariables) ([]interface{}, error) {
Expand Down
72 changes: 0 additions & 72 deletions src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@ import (
"regexp"
"testing"

"github.com/newrelic/infra-integrations-sdk/v3/integration"
"github.com/newrelic/nri-postgresql/src/args"
"github.com/newrelic/nri-postgresql/src/connection"
commonutils "github.com/newrelic/nri-postgresql/src/query-performance-monitoring/common-utils"
Expand All @@ -16,77 +15,6 @@ import (
"gopkg.in/DATA-DOG/go-sqlmock.v1"
)

func TestPopulateBlockingMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(14)
gv := global_variables.SetGlobalVariables(args, version, databaseName)
validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
expectedQuery := queries.BlockingQueriesForV14AndAbove
query := fmt.Sprintf(expectedQuery, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
"newrelic", "blocked_pid", "blocked_query", "blocked_query_id", "blocked_query_start", "database_name",
"blocking_pid", "blocking_query", "blocking_query_id", "blocking_query_start",
}).AddRow(
"newrelic_value", 123, "SELECT 1", 1233444, "2023-01-01 00:00:00", "testdb",
456, "SELECT 2", 4566, "2023-01-01 00:00:00",
))

err := performancemetrics.PopulateBlockingMetrics(conn, pgIntegration, gv)
assert.NoError(t, err)
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateBlockingMetricsSupportedVersionExtensionNotRequired(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(12)
gv := global_variables.SetGlobalVariables(args, version, databaseName)
expectedQuery := queries.BlockingQueriesForV12AndV13
query := fmt.Sprintf(expectedQuery, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
"newrelic", "blocked_pid", "blocked_query", "blocked_query_id", "blocked_query_start", "database_name",
"blocking_pid", "blocking_query", "blocking_query_id", "blocking_query_start",
}).AddRow(
"newrelic_value", 123, "SELECT 1", 1233444, "2023-01-01 00:00:00", "testdb",
456, "SELECT 2", 4566, "2023-01-01 00:00:00",
))
err := performancemetrics.PopulateBlockingMetrics(conn, pgIntegration, gv)
assert.NoError(t, err)
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateBlockingMetricsUnSupportedVersion(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(11)
gv := global_variables.SetGlobalVariables(args, version, databaseName)
err := performancemetrics.PopulateBlockingMetrics(conn, pgIntegration, gv)
assert.EqualError(t, err, commonutils.ErrNotEligible.Error())
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateBlockingMetricsExtensionsNotEnabled(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(14)
gv := global_variables.SetGlobalVariables(args, version, databaseName)
validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
err := performancemetrics.PopulateBlockingMetrics(conn, pgIntegration, gv)
assert.EqualError(t, err, commonutils.ErrNotEligible.Error())
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetBlockingMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
args := args.ArgumentList{QueryCountThreshold: 10}
Expand Down
32 changes: 0 additions & 32 deletions src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@ import (
"regexp"
"testing"

"github.com/newrelic/infra-integrations-sdk/v3/integration"
"github.com/newrelic/nri-postgresql/src/args"
"github.com/newrelic/nri-postgresql/src/connection"
commonutils "github.com/newrelic/nri-postgresql/src/query-performance-monitoring/common-utils"
Expand All @@ -17,37 +16,6 @@ import (
"gopkg.in/DATA-DOG/go-sqlmock.v1"
)

func TestPopulateIndividualQueryMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(13)
gv := global_variables.SetGlobalVariables(args, version, databaseName)
mock.ExpectQuery(regexp.QuoteMeta("SELECT count(*) FROM pg_extension WHERE extname = 'pg_stat_monitor'")).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
mockQueryID := "-123"
mockQueryText := "SELECT 1"
query := fmt.Sprintf(queries.IndividualQuerySearchV13AndAbove, mockQueryID, databaseName, args.QueryResponseTimeThreshold, min(args.QueryCountThreshold, commonutils.MaxIndividualQueryThreshold))
mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
"newrelic", "query", "queryid", "datname", "planid", "avg_cpu_time_ms", "avg_exec_time_ms",
}).AddRow(
"newrelic_value", "SELECT 1", "queryid1", "testdb", "planid1", 10.0, 20.0,
))

slowRunningQueries := []datamodels.SlowRunningQueryMetrics{
{
QueryID: &mockQueryID,
QueryText: &mockQueryText,
DatabaseName: &databaseName,
},
}

individualQueryMetrics := performancemetrics.PopulateIndividualQueryMetrics(conn, slowRunningQueries, pgIntegration, gv)

assert.Len(t, individualQueryMetrics, 1)
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetIndividualQueryMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
args := args.ArgumentList{QueryCountThreshold: 10}
Expand Down
42 changes: 0 additions & 42 deletions src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@ import (
"regexp"
"testing"

"github.com/newrelic/infra-integrations-sdk/v3/integration"
"github.com/newrelic/nri-postgresql/src/args"
"github.com/newrelic/nri-postgresql/src/connection"
commonutils "github.com/newrelic/nri-postgresql/src/query-performance-monitoring/common-utils"
Expand All @@ -16,47 +15,6 @@ import (
"gopkg.in/DATA-DOG/go-sqlmock.v1"
)

func TestPopulateSlowMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(13)
gv := global_variables.SetGlobalVariables(args, version, databaseName)

validationQuery := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQuery)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
expectedQuery := queries.SlowQueriesForV13AndAbove
query := fmt.Sprintf(expectedQuery, "testdb", min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
"newrelic", "query_id", "query_text", "database_name", "schema_name", "execution_count",
"avg_elapsed_time_ms", "avg_disk_reads", "avg_disk_writes", "statement_type", "collection_timestamp",
}).AddRow(
"newrelic_value", "queryid1", "SELECT 1", "testdb", "public", 10,
15.0, 5, 2, "SELECT", "2023-01-01T00:00:00Z",
))

performancemetrics.PopulateSlowRunningMetrics(conn, pgIntegration, gv)

assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateSlowMetricsInEligibility(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(13)
gv := global_variables.SetGlobalVariables(args, version, databaseName)

validationQuery := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQuery)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
slowqueryList := performancemetrics.PopulateSlowRunningMetrics(conn, pgIntegration, gv)

assert.Len(t, slowqueryList, 0)
assert.NoError(t, mock.ExpectationsWereMet())
}

func runSlowQueryTest(t *testing.T, query string, version uint64, expectedLength int) {
conn, mock := connection.CreateMockSQL(t)
args := args.ArgumentList{QueryCountThreshold: 10}
Expand Down
56 changes: 0 additions & 56 deletions src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@ import (
"regexp"
"testing"

"github.com/newrelic/infra-integrations-sdk/v3/integration"
"github.com/newrelic/nri-postgresql/src/args"
"github.com/newrelic/nri-postgresql/src/connection"
commonutils "github.com/newrelic/nri-postgresql/src/query-performance-monitoring/common-utils"
Expand All @@ -16,61 +15,6 @@ import (
"gopkg.in/DATA-DOG/go-sqlmock.v1"
)

func TestPopulateWaitEventMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(13)
gv := global_variables.SetGlobalVariables(args, version, databaseName)

validationQuery := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_wait_sampling")
mock.ExpectQuery(regexp.QuoteMeta(validationQuery)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
var query = fmt.Sprintf(queries.WaitEvents, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
"wait_event_name", "wait_category", "total_wait_time_ms", "collection_timestamp", "query_id", "query_text", "database_name",
}).AddRow(
"Locks:Lock", "Locks", 1000.0, "2023-01-01T00:00:00Z", "queryid1", "SELECT 1", "testdb",
))

err := performancemetrics.PopulateWaitEventMetrics(conn, pgIntegration, gv)
assert.NoError(t, err)
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateWaitEventMetricsInEligibility(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(11)
gv := global_variables.SetGlobalVariables(args, version, databaseName)

err := performancemetrics.PopulateWaitEventMetrics(conn, pgIntegration, gv)
assert.EqualError(t, err, commonutils.ErrNotEligible.Error())
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestPopulateWaitEventMetricsExtensionsNotEnable(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
pgIntegration, _ := integration.New("test", "1.0.0")
args := args.ArgumentList{QueryCountThreshold: 10}
databaseName := "testdb"
version := uint64(13)
gv := global_variables.SetGlobalVariables(args, version, databaseName)

validationQuery := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_wait_sampling")
mock.ExpectQuery(regexp.QuoteMeta(validationQuery)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements")
mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))

err := performancemetrics.PopulateWaitEventMetrics(conn, pgIntegration, gv)
assert.EqualError(t, err, commonutils.ErrNotEligible.Error())
assert.NoError(t, mock.ExpectationsWereMet())
}

func TestGetWaitEventMetrics(t *testing.T) {
conn, mock := connection.CreateMockSQL(t)
args := args.ArgumentList{QueryCountThreshold: 10}
Expand Down
2 changes: 1 addition & 1 deletion src/query-performance-monitoring/query_performance_main.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -49,7 +49,7 @@ func QueryPerformanceMain(args args.ArgumentList, pgIntegration *integration.Int

start = time.Now()
log.Debug("Starting PopulateBlockingMetrics at ", start)
_ = performancemetrics.PopulateBlockingMetrics(newConnection, pgIntegration, gv)
performancemetrics.PopulateBlockingMetrics(newConnection, pgIntegration, gv)
log.Debug("PopulateBlockingMetrics completed in ", time.Since(start))

start = time.Now()
Expand Down
Loading

0 comments on commit 090797b

Please sign in to comment.