refactor(dashboard): added unit tests for helper functions

Author: sasha-bitfly

backend/pkg/api/data_access/vdb_helpers.go

@@ -400,3 +400,186 @@ func (d *DataAccessService) calculateValidatorDashboardBalance(ctx context.Conte
 	}
 	return balances, nil
 }
+
+func (d *DataAccessService) GetLatestExportedChartTs(ctx context.Context, aggregation enums.ChartAggregation) (uint64, error) {
+	view, dateColumn, err := d.getViewAndDateColumn(aggregation)
+	if err != nil {
+		return 0, err
+	}
+
+	query := fmt.Sprintf(`SELECT max(%s) FROM %s`, dateColumn, view)
+	var ts time.Time
+	err = d.clickhouseReader.GetContext(ctx, &ts, query)
+	if err != nil {
+		return 0, fmt.Errorf("error retrieving latest exported chart timestamp: %w", err)
+	}
+
+	return uint64(ts.Unix()), nil
+}
+
+func (d *DataAccessService) getCurrentAndUpcomingSyncCommittees(ctx context.Context, latestEpoch uint64) (map[uint64]bool, map[uint64]bool, error) {
+	currentSyncCommitteeValidators := make(map[uint64]bool)
+	upcomingSyncCommitteeValidators := make(map[uint64]bool)
+
+	currentSyncPeriod := utils.SyncPeriodOfEpoch(latestEpoch)
+	ds := goqu.Dialect("postgres").
+		Select(
+			goqu.L("validatorindex"),
+			goqu.L("period")).
+		From("sync_committees").
+		Where(goqu.L("period IN (?, ?)", currentSyncPeriod, currentSyncPeriod+1))
+
+	var queryResult []struct {
+		ValidatorIndex uint64 `db:"validatorindex"`
+		Period         uint64 `db:"period"`
+	}
+
+	query, args, err := ds.Prepared(true).ToSQL()
+	if err != nil {
+		return nil, nil, fmt.Errorf("error preparing query: %w", err)
+	}
+
+	err = d.readerDb.SelectContext(ctx, &queryResult, query, args...)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error retrieving sync committee current and next period data: %w", err)
+	}
+
+	for _, queryEntry := range queryResult {
+		if queryEntry.Period == currentSyncPeriod {
+			currentSyncCommitteeValidators[queryEntry.ValidatorIndex] = true
+		} else {
+			upcomingSyncCommitteeValidators[queryEntry.ValidatorIndex] = true
+		}
+	}
+
+	return currentSyncCommitteeValidators, upcomingSyncCommitteeValidators, nil
+}
+
+func (d *DataAccessService) getEpochStart(ctx context.Context, period enums.TimePeriod) (uint64, error) {
+	clickhouseTable, _, err := d.getTablesForPeriod(period)
+	if err != nil {
+		return 0, err
+	}
+
+	ds := goqu.Dialect("postgres").
+		Select(goqu.L("epoch_start")).
+		From(goqu.L(fmt.Sprintf("%s FINAL", clickhouseTable))).
+		Order(goqu.L("epoch_start").Asc()).
+		Limit(1)
+
+	query, args, err := ds.Prepared(true).ToSQL()
+	if err != nil {
+		return 0, fmt.Errorf("error preparing query: %w", err)
+	}
+
+	var epochStart uint64
+	err = d.clickhouseReader.GetContext(ctx, &epochStart, query, args...)
+	if err != nil {
+		return 0, fmt.Errorf("error retrieving cutoff epoch for past sync committees: %w", err)
+	}
+
+	return epochStart, nil
+}
+
+func (d *DataAccessService) getPastSyncCommittees(ctx context.Context, indicies []uint64, epochStart uint64, latestEpoch uint64) (map[uint64]uint64, error) {
+	pastSyncPeriodCutoff := utils.SyncPeriodOfEpoch(epochStart)
+	currentSyncPeriod := utils.SyncPeriodOfEpoch(latestEpoch)
+
+	// Get the past sync committee validators
+	ds := goqu.Dialect("postgres").
+		Select(
+			goqu.L("sc.validatorindex")).
+		From(goqu.L("sync_committees sc")).
+		Where(goqu.L("period >= ? AND period < ? AND validatorindex = ANY(?)", pastSyncPeriodCutoff, currentSyncPeriod, pq.Array(indicies)))
+
+	query, args, err := ds.Prepared(true).ToSQL()
+	if err != nil {
+		return nil, fmt.Errorf("error preparing query: %w", err)
+	}
+
+	var validatorIndices []uint64
+	err = d.alloyReader.SelectContext(ctx, &validatorIndices, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("error retrieving data for past sync committees: %w", err)
+	}
+
+	validatorCountMap := make(map[uint64]uint64)
+	for _, validatorIndex := range validatorIndices {
+		validatorCountMap[validatorIndex]++
+	}
+
+	return validatorCountMap, nil
+}
+
+func (d *DataAccessService) getTablesForPeriod(period enums.TimePeriod) (string, int, error) {
+	table := ""
+	hours := 0
+
+	switch period {
+	case enums.TimePeriods.Last1h:
+		table = "validator_dashboard_data_rolling_1h"
+		hours = 1
+	case enums.TimePeriods.Last24h:
+		table = "validator_dashboard_data_rolling_24h"
+		hours = 24
+	case enums.TimePeriods.Last7d:
+		table = "validator_dashboard_data_rolling_7d"
+		hours = 7 * 24
+	case enums.TimePeriods.Last30d:
+		table = "validator_dashboard_data_rolling_30d"
+		hours = 30 * 24
+	case enums.TimePeriods.AllTime:
+		table = "validator_dashboard_data_rolling_total"
+		hours = -1
+	default:
+		return "", 0, fmt.Errorf("not-implemented time period: %v", period)
+	}
+
+	return table, hours, nil
+}
+
+func (d *DataAccessService) getTableAndDateColumn(aggregation enums.ChartAggregation) (string, string, error) {
+	var table, dateColumn string
+
+	switch aggregation {
+	case enums.IntervalEpoch:
+		table = "validator_dashboard_data_epoch"
+		dateColumn = "epoch_timestamp"
+	case enums.IntervalHourly:
+		table = "validator_dashboard_data_hourly"
+		dateColumn = "t"
+	case enums.IntervalDaily:
+		table = "validator_dashboard_data_daily"
+		dateColumn = "t"
+	case enums.IntervalWeekly:
+		table = "validator_dashboard_data_weekly"
+		dateColumn = "t"
+	default:
+		return "", "", fmt.Errorf("unexpected aggregation type: %v", aggregation)
+	}
+
+	return table, dateColumn, nil
+}
+
+func (d *DataAccessService) getViewAndDateColumn(aggregation enums.ChartAggregation) (string, string, error) {
+	var view, dateColumn string
+
+	switch aggregation {
+	case enums.IntervalEpoch:
+		view = "view_validator_dashboard_data_epoch_max_ts"
+		dateColumn = "t"
+	case enums.IntervalHourly:
+		view = "view_validator_dashboard_data_hourly_max_ts"
+		dateColumn = "t"
+	case enums.IntervalDaily:
+		view = "view_validator_dashboard_data_daily_max_ts"
+		dateColumn = "t"
+	case enums.IntervalWeekly:
+		view = "view_validator_dashboard_data_weekly_max_ts"
+		dateColumn = "t"
+	default:
+		return "", "", fmt.Errorf("unexpected aggregation type: %v", aggregation)
+	}
+
+	return view, dateColumn, nil
+}