Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

49.4 KB
Raw Blame
package querier

import (
	"context"
	"encoding/json"
	"fmt"
	"log/slog"
	"testing"
	"time"

	"github.com/SigNoz/signoz/pkg/cache"
	"github.com/SigNoz/signoz/pkg/cache/cachetest"
	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
	"github.com/SigNoz/signoz/pkg/valuer"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

const (
	cacheTTL            = 1 * time.Hour
	defaultFluxInterval = 5 * time.Minute
)

// Helper function to create test cache.
func createTestCache(t *testing.T) cache.Cache {
	config := cache.Config{
		Provider: "memory",
		Memory: cache.Memory{
			NumCounters: 10 * 1000,
			MaxCost:     1 << 26,
		},
	}
	memCache, err := cachetest.New(config)
	require.NoError(t, err)
	return memCache
}

// mockQuery implements the Query interface for testing.
type mockQuery struct {
	fingerprint string
	startMs     uint64
	endMs       uint64
	result      *qbtypes.Result
}

func (m *mockQuery) Fingerprint() string {
	return m.fingerprint
}

func (m *mockQuery) Window() (uint64, uint64) {
	return m.startMs, m.endMs
}

func (m *mockQuery) Execute(ctx context.Context) (*qbtypes.Result, error) {
	if m.result != nil {
		return m.result, nil
	}
	// Default result
	return &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{},
		Stats: qbtypes.ExecStats{
			RowsScanned:  100,
			BytesScanned: 1000,
			DurationMS:   10,
		},
	}, nil
}

// createTestBucketCache creates a test bucket cache.
func createTestBucketCache(t *testing.T) *bucketCache {
	memCache := createTestCache(t)
	return NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval).(*bucketCache)
}

func createTestTimeSeries(queryName string, startMs, endMs uint64, step uint64) *qbtypes.TimeSeriesData {
	series := &qbtypes.TimeSeries{
		Labels: []*qbtypes.Label{
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "method",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "GET",
			},
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "status",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "200",
			},
		},
		Values: []*qbtypes.TimeSeriesValue{},
	}

	// Generate values for each step
	for ts := startMs; ts < endMs; ts += step {
		series.Values = append(series.Values, &qbtypes.TimeSeriesValue{
			Timestamp: int64(ts),
			Value:     float64(ts % 100),
		})
	}

	return &qbtypes.TimeSeriesData{
		QueryName: queryName,
		Aggregations: []*qbtypes.AggregationBucket{
			{
				Index:  0,
				Series: []*qbtypes.TimeSeries{series},
			},
		},
	}
}

func TestBucketCache_GetMissRanges_EmptyCache(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       5000,
	}

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	assert.Nil(t, cached)
	assert.Len(t, missing, 1)
	assert.Equal(t, uint64(1000), missing[0].From)
	assert.Equal(t, uint64(5000), missing[0].To)
}

func TestBucketCache_Put_And_Get(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Create a query and result
	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       5000,
	}

	result := &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 1000, 5000, 1000),
		Stats: qbtypes.ExecStats{
			RowsScanned:  100,
			BytesScanned: 1000,
			DurationMS:   10,
		},
		Warnings: []string{"test warning"},
	}

	// Store in cache
	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Wait a bit for cache to be written
	time.Sleep(10 * time.Millisecond)

	// Retrieve from cache
	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	assert.NotNil(t, cached.Value)
	assert.Len(t, missing, 0)
	assert.Equal(t, qbtypes.RequestTypeTimeSeries, cached.Type)
	assert.Equal(t, uint64(100), cached.Stats.RowsScanned)
	assert.Equal(t, []string{"test warning"}, cached.Warnings)

	// Verify the time series data
	_, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
}

func TestBucketCache_PartialHit(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// First query: cache data for 1000-3000ms
	query1 := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       3000,
	}
	result1 := &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 1000, 3000, 1000),
	}
	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1)

	// Wait for cache write
	time.Sleep(10 * time.Millisecond)

	// Second query: request 2000-5000ms (partial overlap)
	query2 := &mockQuery{
		fingerprint: "test-query",
		startMs:     2000,
		endMs:       5000,
	}

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query2, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have cached data
	assert.NotNil(t, cached.Value)

	// Should have one missing range: 3000-5000
	assert.Len(t, missing, 1)
	assert.Equal(t, uint64(3000), missing[0].From)
	assert.Equal(t, uint64(5000), missing[0].To)
}

func TestBucketCache_MultipleBuckets(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Cache multiple non-contiguous ranges
	query1 := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       2000,
	}
	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 100 * time.Millisecond}, &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 1000, 2000, 100),
	})

	query2 := &mockQuery{
		fingerprint: "test-query",
		startMs:     3000,
		endMs:       4000,
	}
	bc.Put(context.Background(), valuer.UUID{}, query2, qbtypes.Step{Duration: 100 * time.Millisecond}, &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 3000, 4000, 100),
	})

	// Wait for cache writes
	time.Sleep(10 * time.Millisecond)

	// Query spanning all ranges
	query3 := &mockQuery{
		fingerprint: "test-query",
		startMs:     500,
		endMs:       4500,
	}

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query3, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have cached data
	assert.NotNil(t, cached.Value)

	// Should have three missing ranges: 500-1000, 2000-3000, 4000-4500
	assert.Len(t, missing, 3)
	assert.Equal(t, uint64(500), missing[0].From)
	assert.Equal(t, uint64(1000), missing[0].To)
	assert.Equal(t, uint64(2000), missing[1].From)
	assert.Equal(t, uint64(3000), missing[1].To)
	assert.Equal(t, uint64(4000), missing[2].From)
	assert.Equal(t, uint64(4500), missing[2].To)
}

func TestBucketCache_FluxInterval(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Try to cache data too close to current time
	currentMs := uint64(time.Now().UnixMilli())
	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     currentMs - 60000, // 1 minute ago
		endMs:       currentMs,         // now
	}

	result := &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", query.startMs, query.endMs, 1000),
	}

	// This should not be cached due to flux interval
	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Wait a bit
	time.Sleep(10 * time.Millisecond)

	// Try to get the data
	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have no cached data
	assert.Nil(t, cached)
	assert.Len(t, missing, 1)
}

func TestBucketCache_MergeTimeSeriesResults(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Create time series with same labels but different time ranges
	series1 := &qbtypes.TimeSeries{
		Labels: []*qbtypes.Label{
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "method",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "GET",
			},
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "status",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "200",
			},
		},
		Values: []*qbtypes.TimeSeriesValue{
			{Timestamp: 1000, Value: 10},
			{Timestamp: 2000, Value: 20},
		},
	}

	series2 := &qbtypes.TimeSeries{
		Labels: []*qbtypes.Label{
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "method",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "GET",
			},
			{
				Key: telemetrytypes.TelemetryFieldKey{
					Name:          "status",
					FieldDataType: telemetrytypes.FieldDataTypeString,
				},
				Value: "200",
			},
		},
		Values: []*qbtypes.TimeSeriesValue{
			{Timestamp: 3000, Value: 30},
			{Timestamp: 4000, Value: 40},
		},
	}

	// Cache first part
	query1 := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       3000,
	}
	bc.Put(context.Background(), valuer.UUID{}, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{Series: []*qbtypes.TimeSeries{series1}},
			},
		},
	})

	// Cache second part
	query2 := &mockQuery{
		fingerprint: "test-query",
		startMs:     3000,
		endMs:       5000,
	}
	bc.Put(context.Background(), valuer.UUID{}, query2, qbtypes.Step{Duration: 1000 * time.Millisecond}, &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{Series: []*qbtypes.TimeSeries{series2}},
			},
		},
	})

	// Wait for cache writes
	time.Sleep(10 * time.Millisecond)

	// Query full range
	query3 := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       5000,
	}

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query3, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have no missing ranges
	assert.Len(t, missing, 0)

	// Verify merged series
	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	assert.Len(t, tsData.Aggregations[0].Series, 1)

	// Should have all 4 values merged and sorted
	values := tsData.Aggregations[0].Series[0].Values
	assert.Len(t, values, 4)
	assert.Equal(t, int64(1000), values[0].Timestamp)
	assert.Equal(t, int64(2000), values[1].Timestamp)
	assert.Equal(t, int64(3000), values[2].Timestamp)
	assert.Equal(t, int64(4000), values[3].Timestamp)
}

func TestBucketCache_RawData(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Test with raw data type
	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       5000,
	}

	rawData := &qbtypes.RawData{
		QueryName: "test",
		Rows: []*qbtypes.RawRow{
			{
				Timestamp: time.Unix(1, 0),
				Data: map[string]any{
					"value": 10.5,
					"label": "test1",
				},
			},
			{
				Timestamp: time.Unix(2, 0),
				Data: map[string]any{
					"value": 20.5,
					"label": "test2",
				},
			},
		},
	}

	result := &qbtypes.Result{
		Type:  qbtypes.RequestTypeRaw,
		Value: rawData,
	}

	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
	time.Sleep(10 * time.Millisecond)

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Raw data should not be cached
	assert.Nil(t, cached)
	assert.Len(t, missing, 1)
	assert.Equal(t, query.startMs, missing[0].From)
	assert.Equal(t, query.endMs, missing[0].To)
}

func TestBucketCache_ScalarData(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       5000,
	}

	scalarData := &qbtypes.ScalarData{
		Columns: []*qbtypes.ColumnDescriptor{
			{
				TelemetryFieldKey: telemetrytypes.TelemetryFieldKey{Name: "value"},
				QueryName:         "test",
				Type:              qbtypes.ColumnTypeAggregation,
			},
		},
		Data: [][]any{
			{42.5},
		},
	}

	result := &qbtypes.Result{
		Type:  qbtypes.RequestTypeScalar,
		Value: scalarData,
	}

	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
	time.Sleep(10 * time.Millisecond)

	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Scalar data should not be cached
	assert.Nil(t, cached)
	assert.Len(t, missing, 1)
	assert.Equal(t, query.startMs, missing[0].From)
	assert.Equal(t, query.endMs, missing[0].To)
}

func TestBucketCache_EmptyFingerprint(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Query with empty fingerprint should generate a fallback key
	query := &mockQuery{
		fingerprint: "",
		startMs:     1000,
		endMs:       5000,
	}

	result := &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 1000, 5000, 1000),
	}

	bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
	time.Sleep(10 * time.Millisecond)

	// Should still be able to retrieve
	cached, missing := bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
	assert.NotNil(t, cached.Value)
	assert.Len(t, missing, 0)
}

func TestBucketCache_FindMissingRanges_EdgeCases(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval).(*bucketCache)

	// Test with buckets that have gaps and overlaps
	buckets := []*qbtypes.CachedBucket{
		{StartMs: 1000, EndMs: 2000},
		{StartMs: 2500, EndMs: 3500},
		{StartMs: 3000, EndMs: 4000}, // Overlaps with previous
		{StartMs: 5000, EndMs: 6000},
	}

	// Query range that spans all buckets
	missing := bc.findMissingRangesWithStep(buckets, 500, 6500, 500)

	// Expected missing ranges: 500-1000, 2000-2500, 4000-5000, 6000-6500
	assert.Len(t, missing, 4)
	assert.Equal(t, uint64(500), missing[0].From)
	assert.Equal(t, uint64(1000), missing[0].To)
	assert.Equal(t, uint64(2000), missing[1].From)
	assert.Equal(t, uint64(2500), missing[1].To)
	assert.Equal(t, uint64(4000), missing[2].From)
	assert.Equal(t, uint64(5000), missing[2].To)
	assert.Equal(t, uint64(6000), missing[3].From)
	assert.Equal(t, uint64(6500), missing[3].To)
}

func TestBucketCache_ConcurrentAccess(t *testing.T) {
	memCache := createTestCache(t)
	bc := NewBucketCache(instrumentationtest.New().ToProviderSettings(), memCache, cacheTTL, defaultFluxInterval)

	// Test concurrent puts and gets
	done := make(chan bool)

	// Multiple writers
	for i := 0; i < 5; i++ {
		go func(id int) {
			query := &mockQuery{
				fingerprint: fmt.Sprintf("query-%d", id),
				startMs:     uint64(id * 1000),
				endMs:       uint64((id + 1) * 1000),
			}
			result := &qbtypes.Result{
				Type:  qbtypes.RequestTypeTimeSeries,
				Value: createTestTimeSeries(fmt.Sprintf("Q%d", id), query.startMs, query.endMs, 100),
			}
			bc.Put(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 100 * time.Microsecond}, result)
			done <- true
		}(i)
	}

	// Multiple readers
	for i := 0; i < 5; i++ {
		go func(id int) {
			query := &mockQuery{
				fingerprint: fmt.Sprintf("query-%d", id),
				startMs:     uint64(id * 1000),
				endMs:       uint64((id + 1) * 1000),
			}
			bc.GetMissRanges(context.Background(), valuer.UUID{}, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
			done <- true
		}(i)
	}

	// Wait for all goroutines
	for i := 0; i < 10; i++ {
		<-done
	}
}

func TestBucketCache_GetMissRanges_FluxInterval(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Create test query
	query := &mockQuery{
		fingerprint: "test-query",
		startMs:     1000,
		endMs:       10000,
	}

	// Pre-populate cache with data that's outside flux interval
	currentMs := uint64(time.Now().UnixMilli())
	fluxBoundary := currentMs - uint64(defaultFluxInterval.Milliseconds())

	cachedResult := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: 1000, Value: 10},
								{Timestamp: 2000, Value: 20},
								{Timestamp: int64(fluxBoundary - 1000), Value: 30},
							},
						},
					},
				},
			},
		},
	}

	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, cachedResult)

	// Get miss ranges
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
	assert.NotNil(t, cached)
	t.Logf("Missing ranges: %+v, query range: %d-%d", missing, query.startMs, query.endMs)

	// The cache implementation with flux interval handling should either:
	// 1. Have no missing ranges if all data is cached and within bounds
	// 2. Have missing ranges for data beyond flux boundary
	// Since we're caching data that includes a point at fluxBoundary-1000,
	// and our query extends to 10000 (which is way in the past),
	// we expect the entire range to be considered cached
}

func TestBucketCache_Put_FluxIntervalTrimming(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Calculate flux boundary
	currentMs := uint64(time.Now().UnixMilli())
	fluxBoundary := currentMs - uint64(defaultFluxInterval.Milliseconds())

	// Create a query that spans before and after flux boundary
	query := &mockQuery{
		fingerprint: "test-trim-query",
		startMs:     fluxBoundary - 10000, // 10 seconds before flux boundary
		endMs:       currentMs,            // current time
	}

	// Create result with data points before and after flux boundary
	result := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Labels: []*qbtypes.Label{
								{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
							},
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: int64(fluxBoundary - 5000), Value: 10}, // Should be cached
								{Timestamp: int64(fluxBoundary - 1000), Value: 20}, // Should be cached
								{Timestamp: int64(fluxBoundary + 1000), Value: 30}, // Should NOT be cached
								{Timestamp: int64(fluxBoundary + 5000), Value: 40}, // Should NOT be cached
							},
						},
					},
				},
			},
		},
		Stats: qbtypes.ExecStats{
			RowsScanned:  100,
			BytesScanned: 1000,
			DurationMS:   10,
		},
	}

	// Put the result
	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Retrieve cached data
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have cached data
	assert.NotNil(t, cached)

	// Verify that only data before flux boundary was cached
	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	require.Len(t, tsData.Aggregations, 1)
	require.Len(t, tsData.Aggregations[0].Series, 1)

	series := tsData.Aggregations[0].Series[0]
	assert.Len(t, series.Values, 2) // Only 2 values should be cached

	// Verify the cached values are the ones before flux boundary
	assert.Equal(t, int64(fluxBoundary-5000), series.Values[0].Timestamp)
	assert.Equal(t, float64(10), series.Values[0].Value)
	assert.Equal(t, int64(fluxBoundary-1000), series.Values[1].Timestamp)
	assert.Equal(t, float64(20), series.Values[1].Value)

	// Should have missing ranges - one for the gap and one after flux boundary
	t.Logf("Missing ranges: %+v, fluxBoundary: %d", missing, fluxBoundary)
	// We may have multiple missing ranges due to gaps
	assert.True(t, len(missing) >= 1)

	// The last missing range should be after or at the flux boundary
	lastMissing := missing[len(missing)-1]
	assert.True(t, lastMissing.From >= fluxBoundary || lastMissing.To >= fluxBoundary)
}

func TestBucketCache_Put_EntireRangeInFluxInterval(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Calculate flux boundary
	currentMs := uint64(time.Now().UnixMilli())
	fluxBoundary := currentMs - uint64(defaultFluxInterval.Milliseconds())

	// Create a query entirely within flux interval
	query := &mockQuery{
		fingerprint: "test-flux-query",
		startMs:     fluxBoundary + 1000,
		endMs:       currentMs,
	}

	// Create result
	result := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: int64(fluxBoundary + 2000), Value: 10},
								{Timestamp: int64(fluxBoundary + 3000), Value: 20},
							},
						},
					},
				},
			},
		},
	}

	// Put the result - should not cache anything
	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Try to get cached data - should have no cached data
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have no cached value
	assert.Nil(t, cached)

	// Entire range should be missing
	assert.Len(t, missing, 1)
	assert.Equal(t, query.startMs, missing[0].From)
	assert.Equal(t, query.endMs, missing[0].To)
}

func TestBucketCache_EmptyDataHandling(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	tests := []struct {
		name        string
		result      *qbtypes.Result
		shouldCache bool
		description string
	}{
		{
			name: "filtered_empty_time_series",
			result: &qbtypes.Result{
				Type: qbtypes.RequestTypeTimeSeries,
				Value: &qbtypes.TimeSeriesData{
					QueryName: "A",
					Aggregations: []*qbtypes.AggregationBucket{
						{
							Index:  0,
							Series: []*qbtypes.TimeSeries{}, // No series but has aggregation
						},
					},
				},
			},
			shouldCache: true,
			description: "Has aggregations but no series - data was filtered out - should cache",
		},
		{
			name: "series_with_no_values",
			result: &qbtypes.Result{
				Type: qbtypes.RequestTypeTimeSeries,
				Value: &qbtypes.TimeSeriesData{
					QueryName: "A",
					Aggregations: []*qbtypes.AggregationBucket{
						{
							Index: 0,
							Series: []*qbtypes.TimeSeries{
								{
									Labels: []*qbtypes.Label{
										{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
									},
									Values: []*qbtypes.TimeSeriesValue{}, // Series exists but no values
								},
							},
						},
					},
				},
			},
			shouldCache: true,
			description: "Has series but no values - data was filtered - should cache",
		},
		{
			name: "empty_raw_data",
			result: &qbtypes.Result{
				Type: qbtypes.RequestTypeRaw,
				Value: &qbtypes.RawData{
					QueryName: "test",
					Rows:      []*qbtypes.RawRow{},
				},
			},
			shouldCache: false,
			description: "Empty raw data - should not cache",
		},
		{
			name: "empty_scalar_data",
			result: &qbtypes.Result{
				Type: qbtypes.RequestTypeScalar,
				Value: &qbtypes.ScalarData{
					Columns: []*qbtypes.ColumnDescriptor{},
					Data:    [][]any{},
				},
			},
			shouldCache: false,
			description: "Empty scalar data - should not cache",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Use timestamps that are definitely outside flux interval (1 hour ago)
			currentMs := uint64(time.Now().UnixMilli())
			startMs := currentMs - (60 * 60 * 1000) // 1 hour ago
			endMs := startMs + 4000                 // 4 seconds range

			query := &mockQuery{
				fingerprint: "test-empty-" + tt.name,
				startMs:     startMs,
				endMs:       endMs,
			}

			// Put the result
			bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, tt.result)

			// Wait a bit for cache to be written
			time.Sleep(10 * time.Millisecond)

			// Try to get cached data
			cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

			if tt.shouldCache {
				assert.NotNil(t, cached, tt.description)
			} else {
				assert.Nil(t, cached, tt.description)
				assert.Len(t, missing, 1, "Should have entire range as missing when data is not cached")
				if len(missing) > 0 {
					assert.Equal(t, query.startMs, missing[0].From)
					assert.Equal(t, query.endMs, missing[0].To)
				}
			}
		})
	}
}

func TestBucketCache_PartialValues(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Create a query with partial values
	query := &mockQuery{
		fingerprint: "test-partial-query",
		startMs:     1000,
		endMs:       5000,
	}

	// Create result with both partial and non-partial values
	result := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Labels: []*qbtypes.Label{
								{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
							},
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: 1000, Value: 10, Partial: true},  // Partial value - should not be cached
								{Timestamp: 2000, Value: 20, Partial: false}, // Normal value - should be cached
								{Timestamp: 3000, Value: 30, Partial: false}, // Normal value - should be cached
								{Timestamp: 4000, Value: 40, Partial: true},  // Partial value - should not be cached
							},
						},
					},
				},
			},
		},
		Stats: qbtypes.ExecStats{
			RowsScanned:  100,
			BytesScanned: 1000,
			DurationMS:   10,
		},
	}

	// Put the result
	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Wait for cache to be written
	time.Sleep(10 * time.Millisecond)

	// Get cached data
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// Should have cached data
	assert.NotNil(t, cached)
	assert.NotNil(t, cached.Value)
	assert.Len(t, missing, 0) // No missing ranges since we cached the valid values

	// Verify that only non-partial values were cached
	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	require.Len(t, tsData.Aggregations, 1)
	require.Len(t, tsData.Aggregations[0].Series, 1)

	series := tsData.Aggregations[0].Series[0]
	assert.Len(t, series.Values, 2) // Only 2 non-partial values should be cached

	// Verify the cached values are the non-partial ones
	assert.Equal(t, int64(2000), series.Values[0].Timestamp)
	assert.Equal(t, float64(20), series.Values[0].Value)
	assert.False(t, series.Values[0].Partial)

	assert.Equal(t, int64(3000), series.Values[1].Timestamp)
	assert.Equal(t, float64(30), series.Values[1].Value)
	assert.False(t, series.Values[1].Partial)
}

func TestBucketCache_AllPartialValues(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Create a query with all partial values
	query := &mockQuery{
		fingerprint: "test-all-partial-query",
		startMs:     1000,
		endMs:       5000,
	}

	// Create result with only partial values
	result := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Labels: []*qbtypes.Label{
								{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
							},
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: 1000, Value: 10, Partial: true},
								{Timestamp: 2000, Value: 20, Partial: true},
								{Timestamp: 3000, Value: 30, Partial: true},
								{Timestamp: 4000, Value: 40, Partial: true},
							},
						},
					},
				},
			},
		},
	}

	// Put the result
	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)

	// Wait for cache to be written
	time.Sleep(10 * time.Millisecond)

	// Get cached data
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// When all values are partial and filtered out, the result is cached as empty
	// This prevents re-querying for the same misaligned time range
	assert.NotNil(t, cached)
	assert.NotNil(t, cached.Value)
	assert.Len(t, missing, 0)

	// Verify the cached result is empty (all partial values were filtered)
	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	require.Len(t, tsData.Aggregations, 1)
	require.Len(t, tsData.Aggregations[0].Series, 1)

	series := tsData.Aggregations[0].Series[0]
	assert.Len(t, series.Values, 0) // All values were partial and filtered out
}

func TestBucketCache_FilteredCachedResults(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// First, cache data for a wide time range (1000-5000ms)
	query1 := &mockQuery{
		fingerprint: "test-filter-query",
		startMs:     1000,
		endMs:       5000,
	}

	result1 := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Labels: []*qbtypes.Label{
								{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
							},
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: 1000, Value: 10},
								{Timestamp: 2000, Value: 20},
								{Timestamp: 3000, Value: 30},
								{Timestamp: 4000, Value: 40},
							},
						},
					},
				},
			},
		},
	}

	// Cache the wide range
	bc.Put(ctx, orgID, query1, qbtypes.Step{Duration: 1000 * time.Millisecond}, result1)
	time.Sleep(10 * time.Millisecond)

	// Now query for a smaller range (2000-3500ms)
	query2 := &mockQuery{
		fingerprint: "test-filter-query",
		startMs:     2000,
		endMs:       3500,
	}

	// Get cached data - should be filtered to requested range
	cached, missing := bc.GetMissRanges(ctx, orgID, query2, qbtypes.Step{Duration: 1000 * time.Millisecond})

	// The value at 3000 stands for the whole step to 4000, which reaches past the
	// window, so it is left to be recomputed as a partial rather than served.
	require.Len(t, missing, 1)
	assert.Equal(t, uint64(3000), missing[0].From)
	assert.Equal(t, uint64(3500), missing[0].To)
	assert.NotNil(t, cached)

	// Verify the cached result only contains values within the requested range
	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	require.Len(t, tsData.Aggregations, 1)
	require.Len(t, tsData.Aggregations[0].Series, 1)

	series := tsData.Aggregations[0].Series[0]
	require.Len(t, series.Values, 1)

	// Verify the exact values
	assert.Equal(t, int64(2000), series.Values[0].Timestamp)
	assert.Equal(t, float64(20), series.Values[0].Value)

	// Value at 1000 should not be included (before requested range)
	// Value at 4000 should not be included (after requested range)
}

// A promql value is the query evaluated at a single moment rather than over a
// span, so the one at the window's end belongs to it and has to survive caching.
func TestBucketCache_PromQLKeepsTheValueAtTheWindowEnd(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}
	step := qbtypes.Step{Duration: time.Minute}

	query := &promqlQuery{
		logger:      slog.Default(),
		query:       qbtypes.PromQuery{Query: "up", Step: step},
		tr:          qbtypes.TimeRange{From: 600_000, To: 780_000},
		requestType: qbtypes.RequestTypeTimeSeries,
	}

	bc.Put(ctx, orgID, query, step, &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{{
				Series: []*qbtypes.TimeSeries{{
					Values: []*qbtypes.TimeSeriesValue{
						{Timestamp: 600_000, Value: 1},
						{Timestamp: 660_000, Value: 2},
						{Timestamp: 720_000, Value: 3},
						{Timestamp: 780_000, Value: 4},
					},
				}},
			}},
		},
	})
	time.Sleep(10 * time.Millisecond)

	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
	assert.Empty(t, missing)
	require.NotNil(t, cached)

	tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
	require.True(t, ok)
	require.Len(t, tsData.Aggregations, 1)
	require.Len(t, tsData.Aggregations[0].Series, 1)

	timestamps := []int64{}
	for _, value := range tsData.Aggregations[0].Series[0].Values {
		timestamps = append(timestamps, value.Timestamp)
	}
	assert.Equal(t, []int64{600_000, 660_000, 720_000, 780_000}, timestamps)
}

func TestBucketCache_FindMissingRangesWithStep(t *testing.T) {
	bc := createTestBucketCache(t)

	tests := []struct {
		name         string
		buckets      []*qbtypes.CachedBucket
		startMs      uint64
		endMs        uint64
		stepMs       uint64
		expectedMiss []*qbtypes.TimeRange
		description  string
	}{
		{
			name:    "start_not_aligned_to_step",
			buckets: []*qbtypes.CachedBucket{},
			startMs: 1500, // Not aligned to 1000ms step
			endMs:   5000,
			stepMs:  1000,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1500, To: 2000}, // Partial window at start
				{From: 2000, To: 5000}, // Rest of the range
			},
			description: "Start not aligned to step should create partial window",
		},
		{
			name:    "end_not_aligned_to_step",
			buckets: []*qbtypes.CachedBucket{},
			startMs: 1000,
			endMs:   4500, // Not aligned to 1000ms step
			stepMs:  1000,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1000, To: 4500},
			},
			description: "End not aligned to step should be included",
		},
		{
			name: "bucket_boundaries_not_aligned",
			buckets: []*qbtypes.CachedBucket{
				{StartMs: 1500, EndMs: 2500}, // Not aligned
			},
			startMs: 1000,
			endMs:   4000,
			stepMs:  1000,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1000, To: 2000}, // Gap before aligned bucket start
				{From: 2000, To: 4000}, // Gap after aligned bucket end
			},
			description: "Bucket boundaries should be aligned to step",
		},
		{
			name:    "small_window_less_than_step",
			buckets: []*qbtypes.CachedBucket{},
			startMs: 1000,
			endMs:   1500, // Less than one step
			stepMs:  1000,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1000, To: 1500},
			},
			description: "Window smaller than step is fetched whole",
		},
		{
			name: "small_window_less_than_step_inside_a_bucket",
			buckets: []*qbtypes.CachedBucket{
				{StartMs: 0, EndMs: 3000},
			},
			startMs: 1000,
			endMs:   1500,
			stepMs:  1000,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1000, To: 1500},
			},
			description: "A cached point spans its whole step, so it cannot answer a window shorter than the step",
		},
		{
			name:    "zero_step_uses_basic_algorithm",
			buckets: []*qbtypes.CachedBucket{},
			startMs: 1000,
			endMs:   5000,
			stepMs:  0,
			expectedMiss: []*qbtypes.TimeRange{
				{From: 1000, To: 5000},
			},
			description: "Zero step should use basic algorithm",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Mock current time for flux boundary tests
			result := bc.findMissingRangesWithStep(tt.buckets, tt.startMs, tt.endMs, tt.stepMs)

			// Compare lengths first
			assert.Len(t, result, len(tt.expectedMiss), tt.description)

			// Compare individual ranges
			for i, expected := range tt.expectedMiss {
				if i < len(result) {
					assert.Equal(t, expected.From, result[i].From,
						"Range %d From mismatch: %s", i, tt.description)
					assert.Equal(t, expected.To, result[i].To,
						"Range %d To mismatch: %s", i, tt.description)
				}
			}
		})
	}
}

func TestBucketCache_PartialValueDetection(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Test case 1: Query with misaligned start time
	t.Run("misaligned_start_time", func(t *testing.T) {
		// Query from 1500ms to 5000ms with 1000ms step
		// First value at 1500ms should be marked as partial
		query := &mockQuery{
			fingerprint: "test-partial-start",
			startMs:     1500, // Not aligned to 1000ms step
			endMs:       5000,
		}

		result := &qbtypes.Result{
			Type: qbtypes.RequestTypeTimeSeries,
			Value: &qbtypes.TimeSeriesData{
				QueryName: "A",
				Aggregations: []*qbtypes.AggregationBucket{
					{
						Series: []*qbtypes.TimeSeries{
							{
								Labels: []*qbtypes.Label{
									{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
								},
								Values: []*qbtypes.TimeSeriesValue{
									{Timestamp: 1500, Value: 10, Partial: true},  // Partial - misaligned start
									{Timestamp: 2000, Value: 20, Partial: false}, // Complete interval
									{Timestamp: 3000, Value: 30, Partial: false}, // Complete interval
									{Timestamp: 4000, Value: 40, Partial: false}, // Complete interval
								},
							},
						},
					},
				},
			},
		}

		// Put the result
		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
		time.Sleep(10 * time.Millisecond)

		// Get cached data
		cached, _ := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

		// Should have cached data
		assert.NotNil(t, cached)
		tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
		require.True(t, ok)

		// Verify that the partial value was excluded from cache
		series := tsData.Aggregations[0].Series[0]
		assert.Len(t, series.Values, 3) // Only 3 non-partial values
		assert.Equal(t, int64(2000), series.Values[0].Timestamp)
		assert.Equal(t, int64(3000), series.Values[1].Timestamp)
		assert.Equal(t, int64(4000), series.Values[2].Timestamp)
	})

	// Test case 2: Query with misaligned end time
	t.Run("misaligned_end_time", func(t *testing.T) {
		// Query from 1000ms to 4500ms with 1000ms step
		// Last value at 4000ms should be marked as partial (doesn't cover full interval to 5000ms)
		query := &mockQuery{
			fingerprint: "test-partial-end",
			startMs:     1000,
			endMs:       4500, // Not aligned to 1000ms step
		}

		result := &qbtypes.Result{
			Type: qbtypes.RequestTypeTimeSeries,
			Value: &qbtypes.TimeSeriesData{
				QueryName: "A",
				Aggregations: []*qbtypes.AggregationBucket{
					{
						Series: []*qbtypes.TimeSeries{
							{
								Labels: []*qbtypes.Label{
									{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
								},
								Values: []*qbtypes.TimeSeriesValue{
									{Timestamp: 1000, Value: 10, Partial: false}, // Complete interval
									{Timestamp: 2000, Value: 20, Partial: false}, // Complete interval
									{Timestamp: 3000, Value: 30, Partial: false}, // Complete interval
									{Timestamp: 4000, Value: 40, Partial: true},  // Partial - doesn't cover to 5000ms
								},
							},
						},
					},
				},
			},
		}

		// Put the result
		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
		time.Sleep(10 * time.Millisecond)

		// Get cached data
		cached, _ := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

		// Should have cached data
		assert.NotNil(t, cached)
		tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
		require.True(t, ok)

		// Verify that the partial value was excluded from cache
		series := tsData.Aggregations[0].Series[0]
		assert.Len(t, series.Values, 3) // Only 3 non-partial values
		assert.Equal(t, int64(1000), series.Values[0].Timestamp)
		assert.Equal(t, int64(2000), series.Values[1].Timestamp)
		assert.Equal(t, int64(3000), series.Values[2].Timestamp)
	})

	// Test case 3: Query with both misaligned start and end
	t.Run("misaligned_both_start_and_end", func(t *testing.T) {
		query := &mockQuery{
			fingerprint: "test-partial-both",
			startMs:     1500, // Not aligned
			endMs:       4500, // Not aligned
		}

		result := &qbtypes.Result{
			Type: qbtypes.RequestTypeTimeSeries,
			Value: &qbtypes.TimeSeriesData{
				QueryName: "A",
				Aggregations: []*qbtypes.AggregationBucket{
					{
						Series: []*qbtypes.TimeSeries{
							{
								Labels: []*qbtypes.Label{
									{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
								},
								Values: []*qbtypes.TimeSeriesValue{
									{Timestamp: 1500, Value: 10, Partial: true},  // Partial - misaligned start
									{Timestamp: 2000, Value: 20, Partial: false}, // Complete interval
									{Timestamp: 3000, Value: 30, Partial: false}, // Complete interval
									{Timestamp: 4000, Value: 40, Partial: true},  // Partial - misaligned end
								},
							},
						},
					},
				},
			},
		}

		// Put the result
		bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
		time.Sleep(10 * time.Millisecond)

		// Get cached data
		cached, _ := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})

		// Should have cached data
		assert.NotNil(t, cached)
		tsData, ok := cached.Value.(*qbtypes.TimeSeriesData)
		require.True(t, ok)

		// Verify that both partial values were excluded from cache
		series := tsData.Aggregations[0].Series[0]
		assert.Len(t, series.Values, 2) // Only 2 non-partial values
		assert.Equal(t, int64(2000), series.Values[0].Timestamp)
		assert.Equal(t, int64(3000), series.Values[1].Timestamp)
	})
}

func TestBucketCache_NoCache(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}

	// Create a query
	query := &mockQuery{
		fingerprint: "test-nocache-query",
		startMs:     1000,
		endMs:       5000,
	}

	// Create result
	result := &qbtypes.Result{
		Type: qbtypes.RequestTypeTimeSeries,
		Value: &qbtypes.TimeSeriesData{
			QueryName: "A",
			Aggregations: []*qbtypes.AggregationBucket{
				{
					Series: []*qbtypes.TimeSeries{
						{
							Labels: []*qbtypes.Label{
								{Key: telemetrytypes.TelemetryFieldKey{Name: "host"}, Value: "server1"},
							},
							Values: []*qbtypes.TimeSeriesValue{
								{Timestamp: 1000, Value: 10},
								{Timestamp: 2000, Value: 20},
								{Timestamp: 3000, Value: 30},
								{Timestamp: 4000, Value: 40},
							},
						},
					},
				},
			},
		},
	}

	// Put the result in cache
	bc.Put(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond}, result)
	time.Sleep(10 * time.Millisecond)

	// Verify data is cached
	cached, missing := bc.GetMissRanges(ctx, orgID, query, qbtypes.Step{Duration: 1000 * time.Millisecond})
	assert.NotNil(t, cached)
	assert.Len(t, missing, 0)

	// Test NoCache behavior in querier would bypass the cache entirely
	// The actual NoCache logic is implemented in querier.run(), not in bucket cache
	// This test verifies that the cache works normally and NoCache bypasses it at a higher level
}

func TestBucketCachePutSlicesAtCellBoundaries(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}
	step := qbtypes.Step{Duration: time.Second}

	// a 1s step gives 60s cells, so 30s to 150s spans three of them
	query := &mockQuery{fingerprint: "sliced-query", startMs: 30000, endMs: 150000}
	bc.Put(ctx, orgID, query, step, &qbtypes.Result{
		Type:  qbtypes.RequestTypeTimeSeries,
		Value: createTestTimeSeries("A", 30000, 150000, 1000),
		Stats: qbtypes.ExecStats{RowsScanned: 120, BytesScanned: 1200, DurationMS: 12},
	})

	type bucketShape struct {
		cell, startMs, endMs, rowsScanned uint64
		valueCount                        int
	}
	shapes := []bucketShape{}
	for cell := uint64(0); cell < 3; cell++ {
		var cellEntry qbtypes.CachedData
		require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(query, cell), &cellEntry))
		for _, bucket := range cellEntry.Buckets {
			var tsData qbtypes.TimeSeriesData
			require.NoError(t, json.Unmarshal(bucket.Value, &tsData))
			require.Len(t, tsData.Aggregations, 1)
			require.Len(t, tsData.Aggregations[0].Series, 1)
			shapes = append(shapes, bucketShape{cell, bucket.StartMs, bucket.EndMs, bucket.Stats.RowsScanned, len(tsData.Aggregations[0].Series[0].Values)})
		}
	}
	assert.Equal(t, []bucketShape{
		{0, 30000, 60000, 30, 30},
		{1, 60000, 120000, 60, 60},
		{2, 120000, 150000, 30, 30},
	}, shapes)

	cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
	assert.Equal(t, []*qbtypes.TimeRange{}, missing)
	assert.Len(t, cached.Value.(*qbtypes.TimeSeriesData).Aggregations[0].Series[0].Values, 120)
	assert.Equal(t, uint64(120), cached.Stats.RowsScanned)
}

func TestBucketCachePutAbsorbsWritesWithinACell(t *testing.T) {
	type bucketShape struct{ startMs, endMs, rowsScanned uint64 }
	testCases := []struct {
		name                  string
		firstWindow           qbtypes.TimeRange
		secondWindow          qbtypes.TimeRange
		expectedBuckets       []bucketShape
		expectedMissingRanges []*qbtypes.TimeRange
		expectedValueCount    int
	}{
		{
			name:                  "DisjointWrites_StayApart",
			firstWindow:           qbtypes.TimeRange{From: 1000, To: 3000},
			secondWindow:          qbtypes.TimeRange{From: 5000, To: 8000},
			expectedBuckets:       []bucketShape{{1000, 3000, 2}, {5000, 8000, 3}},
			expectedMissingRanges: []*qbtypes.TimeRange{{From: 3000, To: 5000}},
			expectedValueCount:    5,
		},
		{
			name:                  "EdgeToEdgeWrites_BecomeOne",
			firstWindow:           qbtypes.TimeRange{From: 1000, To: 3000},
			secondWindow:          qbtypes.TimeRange{From: 3000, To: 5000},
			expectedBuckets:       []bucketShape{{1000, 5000, 4}},
			expectedMissingRanges: []*qbtypes.TimeRange{},
			expectedValueCount:    4,
		},
		{
			name:                  "OverlappingWrites_BecomeOne",
			firstWindow:           qbtypes.TimeRange{From: 1000, To: 4000},
			secondWindow:          qbtypes.TimeRange{From: 3000, To: 6000},
			expectedBuckets:       []bucketShape{{1000, 6000, 6}},
			expectedMissingRanges: []*qbtypes.TimeRange{},
			expectedValueCount:    5,
		},
		{
			name:                  "ContainedWrite_KeepsExistingBucket",
			firstWindow:           qbtypes.TimeRange{From: 1000, To: 10000},
			secondWindow:          qbtypes.TimeRange{From: 3000, To: 5000},
			expectedBuckets:       []bucketShape{{1000, 10000, 9}},
			expectedMissingRanges: []*qbtypes.TimeRange{},
			expectedValueCount:    9,
		},
		{
			name:                  "ContainingWrite_ReplacesExistingBucket",
			firstWindow:           qbtypes.TimeRange{From: 3000, To: 5000},
			secondWindow:          qbtypes.TimeRange{From: 1000, To: 10000},
			expectedBuckets:       []bucketShape{{1000, 10000, 9}},
			expectedMissingRanges: []*qbtypes.TimeRange{},
			expectedValueCount:    9,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			bc := createTestBucketCache(t)
			ctx := context.Background()
			orgID := valuer.UUID{}
			step := qbtypes.Step{Duration: time.Second}

			for _, window := range []qbtypes.TimeRange{testCase.firstWindow, testCase.secondWindow} {
				query := &mockQuery{fingerprint: "absorb-query", startMs: window.From, endMs: window.To}
				bc.Put(ctx, orgID, query, step, &qbtypes.Result{
					Type:  qbtypes.RequestTypeTimeSeries,
					Value: createTestTimeSeries("A", window.From, window.To, 1000),
					// one row per second, so a bucket's stats read as the seconds it was scanned for
					Stats: qbtypes.ExecStats{RowsScanned: (window.To - window.From) / 1000},
				})
			}

			query := &mockQuery{
				fingerprint: "absorb-query",
				startMs:     min(testCase.firstWindow.From, testCase.secondWindow.From),
				endMs:       max(testCase.firstWindow.To, testCase.secondWindow.To),
			}
			var cellEntry qbtypes.CachedData
			require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(query, 0), &cellEntry))
			shapes := make([]bucketShape, 0, len(cellEntry.Buckets))
			for _, bucket := range cellEntry.Buckets {
				shapes = append(shapes, bucketShape{bucket.StartMs, bucket.EndMs, bucket.Stats.RowsScanned})
			}
			assert.Equal(t, testCase.expectedBuckets, shapes)

			cached, missing := bc.GetMissRanges(ctx, orgID, query, step)
			assert.Equal(t, testCase.expectedMissingRanges, missing)
			assert.Len(t, cached.Value.(*qbtypes.TimeSeriesData).Aggregations[0].Series[0].Values, testCase.expectedValueCount)
		})
	}
}

func TestBucketCachePutLeavesAnUnchangedCellAlone(t *testing.T) {
	bc := createTestBucketCache(t)
	ctx := context.Background()
	orgID := valuer.UUID{}
	step := qbtypes.Step{Duration: time.Second}

	wide := &mockQuery{fingerprint: "unchanged-query", startMs: 1000, endMs: 10000}
	bc.Put(ctx, orgID, wide, step, &qbtypes.Result{
		Type:     qbtypes.RequestTypeTimeSeries,
		Value:    createTestTimeSeries("A", 1000, 10000, 1000),
		Warnings: []string{"from the wide write"},
	})

	// a write already covered by the cell's bucket must not rewrite the entry,
	// which shows as its warnings never arriving
	inside := &mockQuery{fingerprint: "unchanged-query", startMs: 3000, endMs: 5000}
	bc.Put(ctx, orgID, inside, step, &qbtypes.Result{
		Type:     qbtypes.RequestTypeTimeSeries,
		Value:    createTestTimeSeries("A", 3000, 5000, 1000),
		Warnings: []string{"from the inside write"},
	})

	var cellEntry qbtypes.CachedData
	require.NoError(t, bc.cache.Get(ctx, orgID, bc.generateCacheKey(wide, 0), &cellEntry))
	assert.Equal(t, []string{"from the wide write"}, cellEntry.Warnings)
}