chore: refactored the config builder and added base config builder

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/TimeSeriesPanel.tsx

@@ -6,7 +6,6 @@ import { PanelWrapperProps } from 'container/PanelWrapper/panelWrapper.types';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { useResizeObserver } from 'hooks/useDimensions';
 import { LegendPosition } from 'lib/uPlotV2/components/types';
-import { LineInterpolation } from 'lib/uPlotV2/config/types';
 import { ContextMenu } from 'periscope/components/ContextMenu';
 import { useDashboard } from 'providers/Dashboard/Dashboard';
 import { useTimezone } from 'providers/Timezone';
@@ -73,55 +72,28 @@ function TimeSeriesPanel(props: PanelWrapperProps): JSX.Element {
 	}, [queryResponse?.data?.payload]);
 
 	const config = useMemo(() => {
-		const tzDate = (timestamp: number): Date =>
-			uPlot.tzDate(new Date(timestamp * 1e3), timezone.value);
-
 		return prepareUPlotConfig({
-			widgetId: widget.id || '',
-			apiResponse: queryResponse?.data?.payload as MetricRangePayloadProps,
-			tzDate,
-			minTimeScale: minTimeScale,
-			maxTimeScale: maxTimeScale,
-			isLogScale: widget?.isLogScale ?? false,
-			thresholds: {
-				scaleKey: 'y',
-				thresholds: (widget.thresholds || []).map((threshold) => ({
-					thresholdValue: threshold.thresholdValue ?? 0,
-					thresholdColor: threshold.thresholdColor,
-					thresholdUnit: threshold.thresholdUnit,
-					thresholdLabel: threshold.thresholdLabel,
-				})),
-				yAxisUnit: widget.yAxisUnit,
-			},
-			yAxisUnit: widget.yAxisUnit || '',
-			softMin: widget.softMin === undefined ? null : widget.softMin,
-			softMax: widget.softMax === undefined ? null : widget.softMax,
-			spanGaps: false,
-			colorMapping: widget.customLegendColors ?? {},
-			lineInterpolation: LineInterpolation.Spline,
+			widget,
 			isDarkMode,
+			currentQuery: widget.query,
 			onClick: clickHandlerWithContextMenu,
 			onDragSelect,
-			currentQuery: widget.query,
+			apiResponse: queryResponse?.data?.payload as MetricRangePayloadProps,
+			timezone,
 			panelMode,
+			minTimeScale: minTimeScale,
+			maxTimeScale: maxTimeScale,
 		});
 	}, [
-		widget.id,
-		maxTimeScale,
-		minTimeScale,
-		timezone.value,
-		widget.customLegendColors,
-		widget.isLogScale,
-		widget.softMax,
-		widget.softMin,
+		widget,
 		isDarkMode,
-		queryResponse?.data?.payload,
-		widget.query,
-		widget.thresholds,
-		widget.yAxisUnit,
-		panelMode,
 		clickHandlerWithContextMenu,
 		onDragSelect,
+		queryResponse?.data?.payload,
+		panelMode,
+		minTimeScale,
+		maxTimeScale,
+		timezone,
 	]);
 
 	const layoutChildren = useMemo(() => {

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/utils.ts

@@ -1,3 +1,4 @@
+import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import {
 	fillMissingXAxisTimestamps,
@@ -5,23 +6,20 @@ import {
 } from 'container/DashboardContainer/visualization/panels/utils';
 import { getLegend } from 'lib/dashboard/getQueryResults';
 import getLabelName from 'lib/getLabelName';
-import onClickPlugin, {
-	OnClickPluginOpts,
-} from 'lib/uPlotLib/plugins/onClickPlugin';
+import { OnClickPluginOpts } from 'lib/uPlotLib/plugins/onClickPlugin';
 import {
-	DistributionType,
 	DrawStyle,
 	LineInterpolation,
 	LineStyle,
-	SelectionPreferencesSource,
 	VisibilityMode,
 } from 'lib/uPlotV2/config/types';
 import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
-import { ThresholdsDrawHookOptions } from 'lib/uPlotV2/hooks/types';
+import { Widgets } from 'types/api/dashboard/getAll';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 import { PanelMode } from '../types';
+import { buildBaseConfig } from '../utils/baseConfigBuilder';
 
 export const prepareChartData = (
 	apiResponse: MetricRangePayloadProps,
@@ -34,112 +32,39 @@ export const prepareChartData = (
 };
 
 export const prepareUPlotConfig = ({
-	widgetId,
-	apiResponse,
-	tzDate,
-	minTimeScale,
-	maxTimeScale,
-	isLogScale,
-	thresholds,
-	softMin,
-	softMax,
-	spanGaps,
-	colorMapping,
-	lineInterpolation,
+	widget,
 	isDarkMode,
 	currentQuery,
-	onDragSelect,
 	onClick,
-	yAxisUnit,
+	onDragSelect,
+	apiResponse,
+	timezone,
 	panelMode,
+	minTimeScale,
+	maxTimeScale,
 }: {
-	widgetId: string;
-	apiResponse: MetricRangePayloadProps;
-	tzDate: uPlot.LocalDateFromUnix;
-	minTimeScale: number | undefined;
-	maxTimeScale: number | undefined;
-	isLogScale: boolean;
-	softMin: number | null;
-	softMax: number | null;
-	spanGaps: boolean;
-	colorMapping: Record<string, string>;
-	lineInterpolation: LineInterpolation;
+	widget: Widgets;
 	isDarkMode: boolean;
-	thresholds: ThresholdsDrawHookOptions;
 	currentQuery: Query;
-	yAxisUnit: string;
+	onClick: OnClickPluginOpts['onClick'];
 	onDragSelect: (startTime: number, endTime: number) => void;
-	onClick?: OnClickPluginOpts['onClick'];
+	apiResponse: MetricRangePayloadProps;
+	timezone: Timezone;
 	panelMode: PanelMode;
+	minTimeScale?: number;
+	maxTimeScale?: number;
 }): UPlotConfigBuilder => {
-	const builder = new UPlotConfigBuilder({
+	const builder = buildBaseConfig({
+		widget,
+		isDarkMode,
+		onClick,
 		onDragSelect,
-		widgetId,
-		tzDate,
-		shouldSaveSelectionPreference: panelMode === PanelMode.DASHBOARD_VIEW,
-		selectionPreferencesSource: [
-			PanelMode.DASHBOARD_VIEW,
-			PanelMode.STANDALONE_VIEW,
-		].includes(panelMode)
-			? SelectionPreferencesSource.LOCAL_STORAGE
-			: SelectionPreferencesSource.IN_MEMORY,
-	});
-
-	// X scale – time axis
-	builder.addScale({
-		scaleKey: 'x',
-		time: true,
-		min: minTimeScale,
-		max: maxTimeScale,
-		logBase: isLogScale ? 10 : undefined,
-		distribution: isLogScale
-			? DistributionType.Logarithmic
-			: DistributionType.Linear,
-	});
-
-	// Y scale – value axis, driven primarily by softMin/softMax and data
-	builder.addScale({
-		scaleKey: 'y',
-		time: false,
-		min: undefined,
-		max: undefined,
-		softMin: softMin ?? undefined,
-		softMax: softMax ?? undefined,
-		thresholds,
-		logBase: isLogScale ? 10 : undefined,
-		distribution: isLogScale
-			? DistributionType.Logarithmic
-			: DistributionType.Linear,
-	});
-
-	builder.addThresholds(thresholds);
-
-	if (typeof onClick === 'function') {
-		builder.addPlugin(
-			onClickPlugin({
-				onClick,
-				apiResponse,
-			}),
-		);
-	}
-
-	builder.addAxis({
-		scaleKey: 'x',
-		show: true,
-		side: 2,
-		isDarkMode,
-		isLogScale: false,
-		panelType: PANEL_TYPES.TIME_SERIES,
-	});
-
-	builder.addAxis({
-		scaleKey: 'y',
-		show: true,
-		side: 3,
-		isDarkMode,
-		isLogScale: false,
-		yAxisUnit,
+		apiResponse,
+		timezone,
+		panelMode,
 		panelType: PANEL_TYPES.TIME_SERIES,
+		minTimeScale,
+		maxTimeScale,
 	});
 
 	apiResponse.data?.result?.forEach((series) => {
@@ -157,14 +82,16 @@ export const prepareUPlotConfig = ({
 			scaleKey: 'y',
 			drawStyle: DrawStyle.Line,
 			label: label,
-			colorMapping,
-			spanGaps,
+			colorMapping: widget.customLegendColors ?? {},
+			spanGaps: false,
 			lineStyle: LineStyle.Solid,
-			lineInterpolation,
+			lineInterpolation: LineInterpolation.Spline,
 			showPoints: VisibilityMode.Never,
 			pointSize: 5,
 			isDarkMode,
+			panelType: PANEL_TYPES.TIME_SERIES,
 		});
 	});
+
 	return builder;
 };

frontend/src/container/DashboardContainer/visualization/panels/utils/baseConfigBuilder.ts

@@ -0,0 +1,127 @@
+import { Timezone } from 'components/CustomTimePicker/timezoneUtils';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import onClickPlugin, {
+	OnClickPluginOpts,
+} from 'lib/uPlotLib/plugins/onClickPlugin';
+import {
+	DistributionType,
+	SelectionPreferencesSource,
+} from 'lib/uPlotV2/config/types';
+import { UPlotConfigBuilder } from 'lib/uPlotV2/config/UPlotConfigBuilder';
+import { ThresholdsDrawHookOptions } from 'lib/uPlotV2/hooks/types';
+import { Widgets } from 'types/api/dashboard/getAll';
+import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
+import uPlot from 'uplot';
+
+import { PanelMode } from '../types';
+
+export interface BaseConfigBuilderProps {
+	widget: Widgets;
+	apiResponse: MetricRangePayloadProps;
+	isDarkMode: boolean;
+	onClick: OnClickPluginOpts['onClick'];
+	onDragSelect: (startTime: number, endTime: number) => void;
+	timezone: Timezone;
+	panelMode: PanelMode;
+	panelType: PANEL_TYPES;
+	minTimeScale?: number;
+	maxTimeScale?: number;
+}
+
+export function buildBaseConfig({
+	widget,
+	isDarkMode,
+	onClick,
+	onDragSelect,
+	apiResponse,
+	timezone,
+	panelMode,
+	panelType,
+	minTimeScale,
+	maxTimeScale,
+}: BaseConfigBuilderProps): UPlotConfigBuilder {
+	const tzDate = (timestamp: number): Date =>
+		uPlot.tzDate(new Date(timestamp * 1e3), timezone.value);
+
+	const builder = new UPlotConfigBuilder({
+		onDragSelect,
+		widgetId: widget.id,
+		tzDate,
+		shouldSaveSelectionPreference: panelMode === PanelMode.DASHBOARD_VIEW,
+		selectionPreferencesSource: [
+			PanelMode.DASHBOARD_VIEW,
+			PanelMode.STANDALONE_VIEW,
+		].includes(panelMode)
+			? SelectionPreferencesSource.LOCAL_STORAGE
+			: SelectionPreferencesSource.IN_MEMORY,
+	});
+
+	const thresholdOptions: ThresholdsDrawHookOptions = {
+		scaleKey: 'y',
+		thresholds: (widget.thresholds || []).map((threshold) => ({
+			thresholdValue: threshold.thresholdValue ?? 0,
+			thresholdColor: threshold.thresholdColor,
+			thresholdUnit: threshold.thresholdUnit,
+			thresholdLabel: threshold.thresholdLabel,
+		})),
+		yAxisUnit: widget.yAxisUnit,
+	};
+
+	builder.addThresholds(thresholdOptions);
+
+	builder.addScale({
+		scaleKey: 'x',
+		time: true,
+		min: minTimeScale,
+		max: maxTimeScale,
+		logBase: widget.isLogScale ? 10 : undefined,
+		distribution: widget.isLogScale
+			? DistributionType.Logarithmic
+			: DistributionType.Linear,
+	});
+
+	// Y scale – value axis, driven primarily by softMin/softMax and data
+	builder.addScale({
+		scaleKey: 'y',
+		time: false,
+		min: undefined,
+		max: undefined,
+		softMin: widget.softMin ?? undefined,
+		softMax: widget.softMax ?? undefined,
+		// thresholds,
+		logBase: widget.isLogScale ? 10 : undefined,
+		distribution: widget.isLogScale
+			? DistributionType.Logarithmic
+			: DistributionType.Linear,
+	});
+
+	if (typeof onClick === 'function') {
+		builder.addPlugin(
+			onClickPlugin({
+				onClick,
+				apiResponse,
+			}),
+		);
+	}
+
+	builder.addAxis({
+		scaleKey: 'x',
+		show: true,
+		side: 2,
+		isDarkMode,
+		isLogScale: widget.isLogScale,
+		panelType,
+	});
+
+	builder.addAxis({
+		scaleKey: 'y',
+		show: true,
+		side: 3,
+		isDarkMode,
+		isLogScale: widget.isLogScale,
+		yAxisUnit: widget.yAxisUnit,
+		panelType,
+	});
+
+	return builder;
+}

frontend/src/lib/uPlotV2/components/Tooltip/Tooltip.tsx

@@ -3,6 +3,7 @@ import { Virtuoso } from 'react-virtuoso';
 import cx from 'classnames';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 
 import { TooltipContentItem, TooltipProps } from '../types';
@@ -13,6 +14,8 @@ import './Tooltip.styles.scss';
 const TOOLTIP_LIST_MAX_HEIGHT = 330;
 const TOOLTIP_ITEM_HEIGHT = 38;
 
+dayjs.extend(customParseFormat);
+
 export default function Tooltip({
 	seriesIndex,
 	dataIndexes,

frontend/src/lib/uPlotV2/utils/__tests__/dataUtils.test.ts

@@ -1,62 +0,0 @@
-import { isInvalidPlotValue, normalizePlotValue } from '../dataUtils';
-
-describe('dataUtils', () => {
-	describe('isInvalidPlotValue', () => {
-		it('treats null and undefined as invalid', () => {
-			expect(isInvalidPlotValue(null)).toBe(true);
-			expect(isInvalidPlotValue(undefined)).toBe(true);
-		});
-
-		it('treats finite numbers as valid and non-finite as invalid', () => {
-			expect(isInvalidPlotValue(0)).toBe(false);
-			expect(isInvalidPlotValue(123.45)).toBe(false);
-			expect(isInvalidPlotValue(Number.NaN)).toBe(true);
-			expect(isInvalidPlotValue(Infinity)).toBe(true);
-			expect(isInvalidPlotValue(-Infinity)).toBe(true);
-		});
-
-		it('treats well-formed numeric strings as valid', () => {
-			expect(isInvalidPlotValue('0')).toBe(false);
-			expect(isInvalidPlotValue('123.45')).toBe(false);
-			expect(isInvalidPlotValue('-1')).toBe(false);
-		});
-
-		it('treats Infinity/NaN string variants and non-numeric strings as invalid', () => {
-			expect(isInvalidPlotValue('+Inf')).toBe(true);
-			expect(isInvalidPlotValue('-Inf')).toBe(true);
-			expect(isInvalidPlotValue('Infinity')).toBe(true);
-			expect(isInvalidPlotValue('-Infinity')).toBe(true);
-			expect(isInvalidPlotValue('NaN')).toBe(true);
-			expect(isInvalidPlotValue('not-a-number')).toBe(true);
-		});
-
-		it('treats non-number, non-string values as valid (left to caller)', () => {
-			expect(isInvalidPlotValue({})).toBe(false);
-			expect(isInvalidPlotValue([])).toBe(false);
-			expect(isInvalidPlotValue(true)).toBe(false);
-		});
-	});
-
-	describe('normalizePlotValue', () => {
-		it('returns null for invalid values detected by isInvalidPlotValue', () => {
-			expect(normalizePlotValue(null)).toBeNull();
-			expect(normalizePlotValue(undefined)).toBeNull();
-			expect(normalizePlotValue(NaN)).toBeNull();
-			expect(normalizePlotValue(Infinity)).toBeNull();
-			expect(normalizePlotValue('-Infinity')).toBeNull();
-			expect(normalizePlotValue('not-a-number')).toBeNull();
-		});
-
-		it('parses valid numeric strings into numbers', () => {
-			expect(normalizePlotValue('0')).toBe(0);
-			expect(normalizePlotValue('123.45')).toBe(123.45);
-			expect(normalizePlotValue('-1')).toBe(-1);
-		});
-
-		it('passes through valid numbers unchanged', () => {
-			expect(normalizePlotValue(0)).toBe(0);
-			expect(normalizePlotValue(123)).toBe(123);
-			expect(normalizePlotValue(42.5)).toBe(42.5);
-		});
-	});
-});

frontend/src/lib/uPlotV2/utils/__tests__/scale.test.ts

@@ -1,201 +0,0 @@
-import uPlot from 'uplot';
-
-import { DistributionType } from '../../config/types';
-import * as scaleUtils from '../scale';
-
-describe('scale utils', () => {
-	describe('normalizeLogScaleLimits', () => {
-		it('returns limits unchanged when distribution is not logarithmic', () => {
-			const limits = {
-				min: 1,
-				max: 100,
-				softMin: 5,
-				softMax: 50,
-			};
-
-			const result = scaleUtils.normalizeLogScaleLimits({
-				distr: DistributionType.Linear,
-				logBase: 10,
-				limits,
-			});
-
-			expect(result).toEqual(limits);
-		});
-
-		it('snaps positive limits to powers of the log base when distribution is logarithmic', () => {
-			const result = scaleUtils.normalizeLogScaleLimits({
-				distr: DistributionType.Logarithmic,
-				logBase: 10,
-				limits: {
-					min: 3,
-					max: 900,
-					softMin: 12,
-					softMax: 85,
-				},
-			});
-
-			expect(result.min).toBe(1); // 10^0
-			expect(result.max).toBe(1000); // 10^3
-			expect(result.softMin).toBe(10); // 10^1
-			expect(result.softMax).toBe(100); // 10^2
-		});
-	});
-
-	describe('getDistributionConfig', () => {
-		it('returns empty config for time scales', () => {
-			const config = scaleUtils.getDistributionConfig({
-				time: true,
-				distr: DistributionType.Linear,
-				logBase: 2,
-			});
-
-			expect(config).toEqual({});
-		});
-
-		it('returns linear distribution settings for non-time scales', () => {
-			const config = scaleUtils.getDistributionConfig({
-				time: false,
-				distr: DistributionType.Linear,
-				logBase: 2,
-			});
-
-			expect(config.distr).toBe(1);
-			expect(config.log).toBe(2);
-		});
-
-		it('returns log distribution settings for non-time scales', () => {
-			const config = scaleUtils.getDistributionConfig({
-				time: false,
-				distr: DistributionType.Logarithmic,
-				logBase: 10,
-			});
-
-			expect(config.distr).toBe(3);
-			expect(config.log).toBe(10);
-		});
-	});
-
-	describe('getRangeConfig', () => {
-		it('computes range config and fixed range flags correctly', () => {
-			const {
-				rangeConfig,
-				hardMinOnly,
-				hardMaxOnly,
-				hasFixedRange,
-			} = scaleUtils.getRangeConfig(0, 100, null, null, 0.1, 0.2);
-
-			expect(rangeConfig.min).toEqual({
-				pad: 0.1,
-				hard: 0,
-				soft: undefined,
-				mode: 3,
-			});
-			expect(rangeConfig.max).toEqual({
-				pad: 0.2,
-				hard: 100,
-				soft: undefined,
-				mode: 3,
-			});
-			expect(hardMinOnly).toBe(true);
-			expect(hardMaxOnly).toBe(true);
-			expect(hasFixedRange).toBe(true);
-		});
-	});
-
-	describe('createRangeFunction', () => {
-		it('returns [dataMin, dataMax] when no fixed range and no data', () => {
-			const params = {
-				rangeConfig: {} as uPlot.Range.Config,
-				hardMinOnly: false,
-				hardMaxOnly: false,
-				hasFixedRange: false,
-				min: null,
-				max: null,
-			};
-
-			const rangeFn = scaleUtils.createRangeFunction(params);
-
-			const u = ({
-				scales: {
-					y: {
-						distr: 1,
-						log: 10,
-					},
-				},
-			} as unknown) as uPlot;
-
-			const result = rangeFn(
-				u,
-				(null as unknown) as number,
-				(null as unknown) as number,
-				'y',
-			);
-
-			expect(result).toEqual([null, null]);
-		});
-
-		it('applies hard min/max for linear scale when only hard limits are set', () => {
-			const params = {
-				rangeConfig: {} as uPlot.Range.Config,
-				hardMinOnly: true,
-				hardMaxOnly: true,
-				hasFixedRange: true,
-				min: 0,
-				max: 100,
-			};
-
-			const rangeFn = scaleUtils.createRangeFunction(params);
-
-			// Use an undefined distr so the range function skips calling uPlot.rangeNum
-			// and we can focus on the behavior of applyHardLimits.
-			const u = ({
-				scales: {
-					y: {
-						distr: undefined,
-						log: 10,
-					},
-				},
-			} as unknown) as uPlot;
-
-			const result = rangeFn(u, 10, 20, 'y');
-
-			// After applyHardLimits, the returned range should respect configured min/max
-			expect(result).toEqual([0, 100]);
-		});
-	});
-
-	describe('adjustSoftLimitsWithThresholds', () => {
-		it('returns original soft limits when there are no thresholds', () => {
-			const result = scaleUtils.adjustSoftLimitsWithThresholds(1, 5, [], 'ms');
-
-			expect(result).toEqual({ softMin: 1, softMax: 5 });
-		});
-
-		it('expands soft limits to include threshold min/max values', () => {
-			const result = scaleUtils.adjustSoftLimitsWithThresholds(
-				3,
-				6,
-				[{ thresholdValue: 2 }, { thresholdValue: 8 }],
-				'ms',
-			);
-
-			// min should be pulled down to the smallest threshold value
-			expect(result.softMin).toBe(2);
-			// max should be pushed up to the largest threshold value
-			expect(result.softMax).toBe(8);
-		});
-	});
-
-	describe('getFallbackMinMaxTimeStamp', () => {
-		it('returns a 24-hour window ending at approximately now', () => {
-			const { fallbackMin, fallbackMax } = scaleUtils.getFallbackMinMaxTimeStamp();
-
-			// Difference should be exactly one day in seconds
-			expect(fallbackMax - fallbackMin).toBe(86400);
-
-			// Both should be reasonable timestamps (not NaN or negative)
-			expect(fallbackMin).toBeGreaterThan(0);
-			expect(fallbackMax).toBeGreaterThan(fallbackMin);
-		});
-	});
-});

frontend/src/lib/uPlotV2/utils/__tests__/threshold.test.ts

@@ -1,36 +0,0 @@
-import { findMinMaxThresholdValues } from '../threshold';
-
-describe('findMinMaxThresholdValues', () => {
-	it('returns [null, null] when thresholds array is empty or missing', () => {
-		expect(findMinMaxThresholdValues([], 'ms')).toEqual([null, null]);
-		// @ts-expect-error intentional undefined to cover defensive branch
-		expect(findMinMaxThresholdValues(undefined, 'ms')).toEqual([null, null]);
-	});
-
-	it('returns min and max from thresholdValue when units are not provided', () => {
-		const thresholds = [
-			{ thresholdValue: 5 },
-			{ thresholdValue: 1 },
-			{ thresholdValue: 10 },
-		];
-
-		const [min, max] = findMinMaxThresholdValues(thresholds);
-
-		expect(min).toBe(1);
-		expect(max).toBe(10);
-	});
-
-	it('ignores thresholds without a value or with unconvertible units', () => {
-		const thresholds = [
-			// Should be ignored: convertValue returns null for unknown unit
-			{ thresholdValue: 100, thresholdUnit: 'unknown-unit' },
-			// Should be used
-			{ thresholdValue: 4 },
-		];
-
-		const [min, max] = findMinMaxThresholdValues(thresholds, 'ms');
-
-		expect(min).toBe(4);
-		expect(max).toBe(4);
-	});
-});

frontend/src/providers/Dashboard/__tests__/Dashboard.test.tsx

@@ -412,14 +412,16 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			});
 
 			// Verify dashboard state contains the variables with default values
-			const dashboardVariables = await screen.findByTestId('dashboard-variables');
-			const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
+				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
-			expect(parsedVariables).toHaveProperty('environment');
-			expect(parsedVariables).toHaveProperty('services');
-			// Default allSelected values should be preserved
-			expect(parsedVariables.environment.allSelected).toBe(false);
-			expect(parsedVariables.services.allSelected).toBe(false);
+				expect(parsedVariables).toHaveProperty('environment');
+				expect(parsedVariables).toHaveProperty('services');
+				// Default allSelected values should be preserved
+				expect(parsedVariables.environment.allSelected).toBe(false);
+				expect(parsedVariables.services.allSelected).toBe(false);
+			});
 		});
 
 		it('should merge URL variables with dashboard data and normalize values correctly', async () => {
@@ -466,16 +468,26 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			});
 
 			// Verify the dashboard state reflects the normalized URL values
-			const dashboardVariables = await screen.findByTestId('dashboard-variables');
-			const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
+				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
-			// The selectedValue should be updated with normalized URL values
-			expect(parsedVariables.environment.selectedValue).toBe('development');
-			expect(parsedVariables.services.selectedValue).toEqual(['db', 'cache']);
+				// First ensure the variables exist
+				expect(parsedVariables).toHaveProperty('environment');
+				expect(parsedVariables).toHaveProperty('services');
 
-			// allSelected should be set to false when URL values override
-			expect(parsedVariables.environment.allSelected).toBe(false);
-			expect(parsedVariables.services.allSelected).toBe(false);
+				// Then check their properties
+				expect(parsedVariables.environment).toHaveProperty('selectedValue');
+				expect(parsedVariables.services).toHaveProperty('selectedValue');
+
+				// The selectedValue should be updated with normalized URL values
+				expect(parsedVariables.environment.selectedValue).toBe('development');
+				expect(parsedVariables.services.selectedValue).toEqual(['db', 'cache']);
+
+				// allSelected should be set to false when URL values override
+				expect(parsedVariables.environment.allSelected).toBe(false);
+				expect(parsedVariables.services.allSelected).toBe(false);
+			});
 		});
 
 		it('should handle ALL_SELECTED_VALUE from URL and set allSelected correctly', async () => {
@@ -500,8 +512,8 @@ describe('Dashboard Provider - URL Variables Integration', () => {
 			);
 
 			// Verify that allSelected is set to true for the services variable
-			await waitFor(async () => {
-				const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
 				expect(parsedVariables.services.allSelected).toBe(true);
@@ -603,8 +615,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});
 
 			// Verify that defaultValue is set from textboxValue
-			await waitFor(async () => {
-				const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -648,8 +660,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});
 
 			// Verify that existing defaultValue is preserved
-			await waitFor(async () => {
-				const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -694,8 +706,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});
 
 			// Verify that defaultValue is set to empty string
-			await waitFor(async () => {
-				const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
 				expect(parsedVariables.myTextbox.type).toBe('TEXTBOX');
@@ -739,8 +751,8 @@ describe('Dashboard Provider - Textbox Variable Backward Compatibility', () => {
 			});
 
 			// Verify that defaultValue is NOT set from textboxValue for QUERY type
-			await waitFor(async () => {
-				const dashboardVariables = await screen.findByTestId('dashboard-variables');
+			await waitFor(() => {
+				const dashboardVariables = screen.getByTestId('dashboard-variables');
 				const parsedVariables = JSON.parse(dashboardVariables.textContent || '{}');
 
 				expect(parsedVariables.myQuery.type).toBe('QUERY');