add comprehensive backend tests

store/memory.go

@@ -0,0 +1,87 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"sync"
+	"time"
+)
+
+var ErrNotFound = errors.New("key not found")
+
+type entry struct {
+	data     []byte
+	expireAt time.Time
+}
+
+// Memory is an in-memory store for testing
+type Memory struct {
+	mu   sync.RWMutex
+	data map[string]entry
+}
+
+func NewMemory() *Memory {
+	return &Memory{
+		data: make(map[string]entry),
+	}
+}
+
+func (m *Memory) Get(ctx context.Context, key string, v any) error {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	e, ok := m.data[key]
+	if !ok {
+		return ErrNotFound
+	}
+	if !e.expireAt.IsZero() && time.Now().After(e.expireAt) {
+		return ErrNotFound
+	}
+	return json.Unmarshal(e.data, v)
+}
+
+func (m *Memory) Set(ctx context.Context, key string, v any, expireAt time.Time) error {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.data[key] = entry{data: data, expireAt: expireAt}
+	return nil
+}
+
+func (m *Memory) SetTTL(ctx context.Context, key string, v any, ttl time.Duration) error {
+	return m.Set(ctx, key, v, time.Now().Add(ttl))
+}
+
+func (m *Memory) Delete(ctx context.Context, key string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	delete(m.data, key)
+	return nil
+}
+
+func (m *Memory) Exists(ctx context.Context, key string) (bool, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	e, ok := m.data[key]
+	if !ok {
+		return false, nil
+	}
+	if !e.expireAt.IsZero() && time.Now().After(e.expireAt) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (m *Memory) Clear() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.data = make(map[string]entry)
+}

store/memory_test.go

@@ -0,0 +1,136 @@
+package store
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestMemoryStore(t *testing.T) {
+	ctx := context.Background()
+	m := NewMemory()
+
+	t.Run("set and get", func(t *testing.T) {
+		data := map[string]string{"foo": "bar"}
+		err := m.Set(ctx, "test1", data, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("set failed: %v", err)
+		}
+
+		var result map[string]string
+		err = m.Get(ctx, "test1", &result)
+		if err != nil {
+			t.Fatalf("get failed: %v", err)
+		}
+		if result["foo"] != "bar" {
+			t.Errorf("expected bar, got: %s", result["foo"])
+		}
+	})
+
+	t.Run("get nonexistent", func(t *testing.T) {
+		var result string
+		err := m.Get(ctx, "nonexistent", &result)
+		if err != ErrNotFound {
+			t.Errorf("expected ErrNotFound, got: %v", err)
+		}
+	})
+
+	t.Run("exists", func(t *testing.T) {
+		m.Set(ctx, "exists-test", "value", time.Now().Add(time.Hour))
+
+		exists, err := m.Exists(ctx, "exists-test")
+		if err != nil {
+			t.Fatalf("exists failed: %v", err)
+		}
+		if !exists {
+			t.Error("expected exists to be true")
+		}
+
+		exists, err = m.Exists(ctx, "nonexistent")
+		if err != nil {
+			t.Fatalf("exists failed: %v", err)
+		}
+		if exists {
+			t.Error("expected exists to be false")
+		}
+	})
+
+	t.Run("delete", func(t *testing.T) {
+		m.Set(ctx, "delete-test", "value", time.Now().Add(time.Hour))
+
+		err := m.Delete(ctx, "delete-test")
+		if err != nil {
+			t.Fatalf("delete failed: %v", err)
+		}
+
+		exists, _ := m.Exists(ctx, "delete-test")
+		if exists {
+			t.Error("expected key to be deleted")
+		}
+	})
+
+	t.Run("expiration", func(t *testing.T) {
+		m.Set(ctx, "expire-test", "value", time.Now().Add(-time.Second))
+
+		var result string
+		err := m.Get(ctx, "expire-test", &result)
+		if err != ErrNotFound {
+			t.Errorf("expected ErrNotFound for expired key, got: %v", err)
+		}
+
+		exists, _ := m.Exists(ctx, "expire-test")
+		if exists {
+			t.Error("expected expired key to not exist")
+		}
+	})
+
+	t.Run("set with ttl", func(t *testing.T) {
+		err := m.SetTTL(ctx, "ttl-test", "value", time.Hour)
+		if err != nil {
+			t.Fatalf("setTTL failed: %v", err)
+		}
+
+		exists, _ := m.Exists(ctx, "ttl-test")
+		if !exists {
+			t.Error("expected key to exist")
+		}
+	})
+
+	t.Run("clear", func(t *testing.T) {
+		m.Set(ctx, "clear-test", "value", time.Now().Add(time.Hour))
+		m.Clear()
+
+		exists, _ := m.Exists(ctx, "clear-test")
+		if exists {
+			t.Error("expected store to be cleared")
+		}
+	})
+
+	t.Run("complex types", func(t *testing.T) {
+		type nested struct {
+			Points [][]float64 `json:"points"`
+			Name   string      `json:"name"`
+		}
+		data := nested{
+			Points: [][]float64{{1.5, 2.5}, {3.5, 4.5}},
+			Name:   "test",
+		}
+
+		err := m.Set(ctx, "complex", data, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("set failed: %v", err)
+		}
+
+		var result nested
+		err = m.Get(ctx, "complex", &result)
+		if err != nil {
+			t.Fatalf("get failed: %v", err)
+		}
+		if result.Name != "test" {
+			t.Errorf("expected test, got: %s", result.Name)
+		}
+		if len(result.Points) != 2 {
+			t.Errorf("expected 2 points, got: %d", len(result.Points))
+		}
+	})
+}

store/redis_test.go

@@ -0,0 +1,209 @@
+package store
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+)
+
+func getRedisAddr() string {
+	if addr := os.Getenv("TEST_REDIS_ADDR"); addr != "" {
+		return addr
+	}
+	return "localhost:16379"
+}
+
+func TestRedisStore(t *testing.T) {
+	ctx := context.Background()
+
+	r, err := NewRedis(getRedisAddr(), "", "hauk-test")
+	if err != nil {
+		t.Skipf("redis not available: %v", err)
+	}
+	defer r.Close()
+
+	t.Run("set and get", func(t *testing.T) {
+		data := map[string]string{"foo": "bar"}
+		err := r.Set(ctx, "test1", data, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("set failed: %v", err)
+		}
+
+		var result map[string]string
+		err = r.Get(ctx, "test1", &result)
+		if err != nil {
+			t.Fatalf("get failed: %v", err)
+		}
+		if result["foo"] != "bar" {
+			t.Errorf("expected bar, got: %s", result["foo"])
+		}
+	})
+
+	t.Run("get nonexistent", func(t *testing.T) {
+		var result string
+		err := r.Get(ctx, "nonexistent-redis-key", &result)
+		if err == nil {
+			t.Error("expected error for nonexistent key")
+		}
+	})
+
+	t.Run("exists", func(t *testing.T) {
+		r.Set(ctx, "exists-test", "value", time.Now().Add(time.Hour))
+
+		exists, err := r.Exists(ctx, "exists-test")
+		if err != nil {
+			t.Fatalf("exists failed: %v", err)
+		}
+		if !exists {
+			t.Error("expected exists to be true")
+		}
+
+		exists, err = r.Exists(ctx, "nonexistent-key")
+		if err != nil {
+			t.Fatalf("exists failed: %v", err)
+		}
+		if exists {
+			t.Error("expected exists to be false")
+		}
+	})
+
+	t.Run("delete", func(t *testing.T) {
+		r.Set(ctx, "delete-test", "value", time.Now().Add(time.Hour))
+
+		err := r.Delete(ctx, "delete-test")
+		if err != nil {
+			t.Fatalf("delete failed: %v", err)
+		}
+
+		exists, _ := r.Exists(ctx, "delete-test")
+		if exists {
+			t.Error("expected key to be deleted")
+		}
+	})
+
+	t.Run("expiration", func(t *testing.T) {
+		// set with 1s TTL and poll for expiration
+		r.SetTTL(ctx, "ttl-expire-test", "value", time.Second)
+
+		// poll for expiration with timeout
+		deadline := time.Now().Add(3 * time.Second)
+		for time.Now().Before(deadline) {
+			exists, _ := r.Exists(ctx, "ttl-expire-test")
+			if !exists {
+				return // success
+			}
+			time.Sleep(100 * time.Millisecond)
+		}
+		t.Error("key did not expire within timeout")
+	})
+
+	t.Run("complex types", func(t *testing.T) {
+		type nested struct {
+			Points [][]float64 `json:"points"`
+			Name   string      `json:"name"`
+		}
+		data := nested{
+			Points: [][]float64{{1.5, 2.5}, {3.5, 4.5}},
+			Name:   "test",
+		}
+
+		err := r.Set(ctx, "complex-redis", data, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("set failed: %v", err)
+		}
+
+		var result nested
+		err = r.Get(ctx, "complex-redis", &result)
+		if err != nil {
+			t.Fatalf("get failed: %v", err)
+		}
+		if result.Name != "test" {
+			t.Errorf("expected test, got: %s", result.Name)
+		}
+		if len(result.Points) != 2 {
+			t.Errorf("expected 2 points, got: %d", len(result.Points))
+		}
+	})
+
+	t.Run("key prefixing", func(t *testing.T) {
+		// keys should be prefixed
+		r.Set(ctx, "prefix-test", "value", time.Now().Add(time.Hour))
+
+		// the internal key should be "hauk-test-prefix-test"
+		exists, _ := r.Exists(ctx, "prefix-test")
+		if !exists {
+			t.Error("expected prefixed key to exist")
+		}
+	})
+}
+
+func TestRedisIntegration(t *testing.T) {
+	ctx := context.Background()
+
+	r, err := NewRedis(getRedisAddr(), "", "hauk-integration")
+	if err != nil {
+		t.Skipf("redis not available: %v", err)
+	}
+	defer r.Close()
+
+	// test full session lifecycle like the API does
+	type sessionData struct {
+		ID       string   `json:"id"`
+		Targets  []string `json:"targets"`
+		Interval float64  `json:"interval"`
+	}
+
+	t.Run("session lifecycle", func(t *testing.T) {
+		session := sessionData{
+			ID:       "test-session-123",
+			Targets:  []string{"share-abc"},
+			Interval: 5.0,
+		}
+
+		// save session
+		err := r.Set(ctx, "session-"+session.ID, session, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("save session failed: %v", err)
+		}
+
+		// load session
+		var loaded sessionData
+		err = r.Get(ctx, "session-"+session.ID, &loaded)
+		if err != nil {
+			t.Fatalf("load session failed: %v", err)
+		}
+
+		if loaded.ID != session.ID {
+			t.Errorf("ID mismatch: %s vs %s", loaded.ID, session.ID)
+		}
+		if len(loaded.Targets) != 1 || loaded.Targets[0] != "share-abc" {
+			t.Errorf("targets mismatch: %v", loaded.Targets)
+		}
+
+		// update session
+		loaded.Targets = append(loaded.Targets, "share-def")
+		err = r.Set(ctx, "session-"+loaded.ID, loaded, time.Now().Add(time.Hour))
+		if err != nil {
+			t.Fatalf("update session failed: %v", err)
+		}
+
+		// verify update
+		var updated sessionData
+		r.Get(ctx, "session-"+loaded.ID, &updated)
+		if len(updated.Targets) != 2 {
+			t.Errorf("expected 2 targets after update, got: %d", len(updated.Targets))
+		}
+
+		// delete session
+		err = r.Delete(ctx, "session-"+loaded.ID)
+		if err != nil {
+			t.Fatalf("delete session failed: %v", err)
+		}
+
+		exists, _ := r.Exists(ctx, "session-"+loaded.ID)
+		if exists {
+			t.Error("session should be deleted")
+		}
+	})
+}