From 80d9b95c456d46770978d866bd7ced6dea5302fe Mon Sep 17 00:00:00 2001 From: tharun0064 Date: Wed, 22 Jan 2025 17:32:21 +0530 Subject: [PATCH] Feat: refactored unit test cases (#57) * resolved: refactored unit test cases --- .../performance-metrics/blocking_sessions.go | 11 +- .../blocking_sessions_test.go | 72 ---------- .../individual_query_metrics_test.go | 32 ----- .../slow_query_metrics_test.go | 42 ------ .../wait_event_metrics_test.go | 56 -------- .../query_performance_main.go | 2 +- .../performance_metrics_validations_test.go | 136 ++++++++++++++++++ 7 files changed, 142 insertions(+), 209 deletions(-) create mode 100644 src/query-performance-monitoring/validations/performance_metrics_validations_test.go diff --git a/src/query-performance-monitoring/performance-metrics/blocking_sessions.go b/src/query-performance-monitoring/performance-metrics/blocking_sessions.go index 48553e64..44c95684 100644 --- a/src/query-performance-monitoring/performance-metrics/blocking_sessions.go +++ b/src/query-performance-monitoring/performance-metrics/blocking_sessions.go @@ -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) { diff --git a/src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go b/src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go index 005c5611..4a6a14dd 100644 --- a/src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go +++ b/src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go @@ -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" @@ -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} diff --git a/src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go b/src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go index 1835ead7..23b8ea17 100644 --- a/src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go +++ b/src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go @@ -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" @@ -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} diff --git a/src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go b/src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go index 69bceac4..842a1610 100644 --- a/src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go +++ b/src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go @@ -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" @@ -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} diff --git a/src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go b/src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go index 251053e2..76b004c4 100644 --- a/src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go +++ b/src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go @@ -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" @@ -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} diff --git a/src/query-performance-monitoring/query_performance_main.go b/src/query-performance-monitoring/query_performance_main.go index 9ebccbaf..5b8dd340 100644 --- a/src/query-performance-monitoring/query_performance_main.go +++ b/src/query-performance-monitoring/query_performance_main.go @@ -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() diff --git a/src/query-performance-monitoring/validations/performance_metrics_validations_test.go b/src/query-performance-monitoring/validations/performance_metrics_validations_test.go new file mode 100644 index 00000000..9f84ad09 --- /dev/null +++ b/src/query-performance-monitoring/validations/performance_metrics_validations_test.go @@ -0,0 +1,136 @@ +package validations + +import ( + "fmt" + "regexp" + "testing" + + "github.com/newrelic/nri-postgresql/src/connection" + "github.com/stretchr/testify/assert" + "gopkg.in/DATA-DOG/go-sqlmock.v1" +) + +func TestCheckBlockingSessionMetricsFetchEligibilityExtensionNotRequired(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(12) + isExtensionEnabledTest, _ := CheckBlockingSessionMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, true) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckBlockingSessionMetricsFetchEligibilityUnsupportedVersion(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(11) + isExtensionEnabledTest, _ := CheckBlockingSessionMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckBlockingSessionMetricsFetchEligibilitySupportedVersionSuccess(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + 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)) + isExtensionEnabledTest, _ := CheckBlockingSessionMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, true) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckBlockingSessionMetricsFetchEligibilitySupportedVersionFail(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + 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)) + isExtensionEnabledTest, _ := CheckBlockingSessionMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, true) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestIndividualQueryMetricsFetchEligibilityUnSupportedVersion(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(11) + isExtensionEnabledTest, _ := CheckIndividualQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestIndividualQueryMetricsFetchEligibilitySupportedVersionSuccess(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_monitor") + mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1)) + isExtensionEnabledTest, _ := CheckIndividualQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, true) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestIndividualQueryMetricsFetchEligibilitySupportedVersionFail(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + validationQueryStatStatements := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_monitor") + mock.ExpectQuery(regexp.QuoteMeta(validationQueryStatStatements)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0)) + isExtensionEnabledTest, _ := CheckIndividualQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckWaitEventMetricsFetchEligibilityUnsupportedVersion(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(11) + isExtensionEnabledTest, _ := CheckWaitEventMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckWaitEventMetricsFetchEligibility(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(15) + validationWait := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_wait_sampling") + validationStat := fmt.Sprintf("SELECT count(*) FROM pg_extension WHERE extname = '%s'", "pg_stat_statements") + + testCases := []struct { + waitCount int + statCount int + expected bool + }{ + {1, 1, true}, // Success + {0, 1, false}, // Fail V1 + {1, 0, false}, // Fail V2 + } + + for _, tc := range testCases { + mock.ExpectQuery(regexp.QuoteMeta(validationWait)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(tc.waitCount)) + mock.ExpectQuery(regexp.QuoteMeta(validationStat)).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(tc.statCount)) + isExtensionEnabledTest, _ := CheckWaitEventMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, tc.expected) + assert.NoError(t, mock.ExpectationsWereMet()) + } +} + +func TestCheckSlowQueryMetricsFetchEligibilityUnSupportedVersion(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(11) + isExtensionEnabledTest, _ := CheckSlowQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckSlowQueryMetricsFetchEligibilitySupportedVersionSuccess(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + 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)) + isExtensionEnabledTest, _ := CheckSlowQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, true) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +func TestCheckSlowQueryMetricsFetchEligibilitySupportedVersionFail(t *testing.T) { + conn, mock := connection.CreateMockSQL(t) + version := uint64(14) + 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)) + isExtensionEnabledTest, _ := CheckSlowQueryMetricsFetchEligibility(conn, version) + assert.Equal(t, isExtensionEnabledTest, false) + assert.NoError(t, mock.ExpectationsWereMet()) +}