Initial commit: stats-gateway gRPC service + dashboard + CLI

internal/storage/sqlite_test.go

@@ -0,0 +1,106 @@
+package storage
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/bergabruh/stats-gateway/internal/probes"
+)
+
+func TestInsertAndQuery(t *testing.T) {
+	dir := t.TempDir()
+	st, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+
+	ctx := context.Background()
+	r := &probes.Result{
+		HTTPLatencyMs:  42.5,
+		TCPRttMs:       12.0,
+		DNSResolveMs:   3.0,
+		TLSHandshakeMs: 25.0,
+		Timestamp:      time.Now().UTC(),
+	}
+	if err := st.InsertSample(ctx, "fl", r); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	samples, err := st.QueryRecent(ctx, "fl", 10, time.Time{})
+	if err != nil {
+		t.Fatalf("query: %v", err)
+	}
+	if len(samples) != 1 {
+		t.Fatalf("expected 1 sample, got %d", len(samples))
+	}
+	if samples[0].HTTPLatencyMs != 42.5 {
+		t.Errorf("expected latency 42.5, got %f", samples[0].HTTPLatencyMs)
+	}
+}
+
+func TestQueryRange(t *testing.T) {
+	dir := t.TempDir()
+	st, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+
+	ctx := context.Background()
+	now := time.Now().UTC().Truncate(time.Second)
+	for i, dt := range []time.Duration{-2 * time.Hour, -1 * time.Hour, 0, 1 * time.Hour} {
+		r := &probes.Result{HTTPLatencyMs: float64(10 + i), Timestamp: now.Add(dt)}
+		if err := st.InsertSample(ctx, "fl", r); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	got, err := st.QueryRange(ctx, "fl", now.Add(-90*time.Minute), now.Add(30*time.Minute))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// expect 2 samples: -1h and 0
+	if len(got) != 2 {
+		t.Fatalf("expected 2, got %d", len(got))
+	}
+}
+
+// TestQueryRange_SubsecondOrdering verifies fixed-width nanosecond format —
+// regression guard for RFC3339Nano trailing-zero stripping bug.
+func TestQueryRange_SubsecondOrdering(t *testing.T) {
+	dir := t.TempDir()
+	st, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+
+	ctx := context.Background()
+	base := time.Date(2026, 5, 5, 12, 0, 0, 0, time.UTC)
+	// Two timestamps where lexical ordering of RFC3339Nano disagrees with chronology:
+	//   t1 = base + 100ms  → RFC3339Nano formats as "...:00.1Z"
+	//   t2 = base + 100ms + 1ns → RFC3339Nano formats as "...:00.100000001Z"
+	// Lexically ".1Z" > ".100000001Z" because 'Z' > '0', but t1 < t2.
+	t1 := base.Add(100 * time.Millisecond)
+	t2 := base.Add(100*time.Millisecond + time.Nanosecond)
+	for _, ts := range []time.Time{t1, t2} {
+		if err := st.InsertSample(ctx, "fl", &probes.Result{HTTPLatencyMs: 1.0, Timestamp: ts}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Range starting just before t1 must include both samples.
+	got, err := st.QueryRange(ctx, "fl", base.Add(50*time.Millisecond), base.Add(200*time.Millisecond))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("expected 2 samples in [t-50ms, t+200ms), got %d — lexical ordering bug?", len(got))
+	}
+	// Verify chronological ordering preserved on read.
+	if !got[0].Timestamp.Before(got[1].Timestamp) {
+		t.Errorf("expected got[0] < got[1] chronologically; got[0]=%v got[1]=%v", got[0].Timestamp, got[1].Timestamp)
+	}
+}