projax/store/views_test.go

package store_test

import (
	"context"
	"errors"
	"os"
	"strings"
	"testing"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	"github.com/m/projax/store"
)

// connect mirrors db_test's connect helper. The store package owns its own
// integration tests (Phase 5j Slice A introduced this file alongside the
// schema redesign); it shares the same env-var convention to skip when no
// DB is wired up.
func connect(t *testing.T) (*pgxpool.Pool, *store.Store) {
	t.Helper()
	url := os.Getenv("PROJAX_DB_URL")
	if url == "" {
		url = os.Getenv("SUPABASE_DATABASE_URL")
	}
	if url == "" {
		t.Skip("no PROJAX_DB_URL / SUPABASE_DATABASE_URL set — skipping integration test")
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	pool, err := pgxpool.New(ctx, url)
	if err != nil {
		t.Fatalf("pool: %v", err)
	}
	if err := pool.Ping(ctx); err != nil {
		t.Skipf("DB unreachable: %v", err)
	}
	return pool, store.New(pool)
}

// uniqueSlug suffixes a base slug with a timestamp so parallel test runs
// don't collide on the views_slug_uniq index.
func uniqueSlug(prefix string) string {
	return prefix + "-" + strings.ReplaceAll(time.Now().UTC().Format("150405.000"), ".", "")
}

func TestViewSlugCRUD(t *testing.T) {
	pool, s := connect(t)
	defer pool.Close()
	ctx := context.Background()
	slug := uniqueSlug("p5j-a-crud")
	defer pool.Exec(context.Background(), `DELETE FROM projax.views WHERE slug LIKE 'p5j-a-crud-%' OR slug LIKE 'p5j-a-renamed-%'`)

	// Create.
	created, err := s.CreateView(ctx, store.ViewInput{
		Slug:       slug,
		Name:       "Slice A CRUD",
		FilterJSON: []byte(`{"view_type":"list","tags":["work"]}`),
	})
	if err != nil {
		t.Fatalf("create: %v", err)
	}
	if created.Slug != slug {
		t.Errorf("slug = %q, want %q", created.Slug, slug)
	}
	if created.ID == "" {
		t.Error("ID should be populated on create")
	}
	if created.SortOrder < 0 {
		t.Errorf("sort_order should be >= 0 (server-assigned), got %d", created.SortOrder)
	}

	// GetView by slug.
	got, err := s.GetView(ctx, slug)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if string(got.FilterJSON) != `{"view_type": "list", "tags": ["work"]}` && string(got.FilterJSON) != `{"tags": ["work"], "view_type": "list"}` {
		// Postgres jsonb normalises key order — accept either ordering.
		// Verify it round-trips structurally.
		if !strings.Contains(string(got.FilterJSON), `"view_type"`) || !strings.Contains(string(got.FilterJSON), `"tags"`) {
			t.Errorf("filter_json did not round-trip view_type+tags: %s", got.FilterJSON)
		}
	}

	// GetViewByID (legacy 5i 302-redirect path uses this).
	byID, err := s.GetViewByID(ctx, created.ID)
	if err != nil {
		t.Fatalf("get by id: %v", err)
	}
	if byID.Slug != slug {
		t.Errorf("by-id lookup returned wrong slug: %q", byID.Slug)
	}

	// Update — rename slug + change filter.
	renamed := uniqueSlug("p5j-a-renamed")
	updated, err := s.UpdateView(ctx, slug, store.ViewInput{
		Slug:       renamed,
		Name:       "Renamed",
		FilterJSON: []byte(`{"view_type":"card"}`),
	})
	if err != nil {
		t.Fatalf("update: %v", err)
	}
	if updated.Slug != renamed {
		t.Errorf("renamed slug = %q, want %q", updated.Slug, renamed)
	}
	if _, err := s.GetView(ctx, slug); !errors.Is(err, store.ErrViewNotFound) {
		t.Errorf("old slug should be ErrViewNotFound after rename, got %v", err)
	}

	// Delete.
	if err := s.DeleteView(ctx, renamed); err != nil {
		t.Fatalf("delete: %v", err)
	}
	if _, err := s.GetView(ctx, renamed); !errors.Is(err, store.ErrViewNotFound) {
		t.Errorf("post-delete get should be ErrViewNotFound, got %v", err)
	}
	if err := s.DeleteView(ctx, renamed); !errors.Is(err, store.ErrViewNotFound) {
		t.Errorf("second delete should be ErrViewNotFound, got %v", err)
	}
}

func TestViewSlugFormatRejected(t *testing.T) {
	pool, s := connect(t)
	defer pool.Close()
	ctx := context.Background()
	bad := []string{
		"",                                                                   // empty
		"UPPER",                                                              // uppercase
		"under_score",                                                        // underscore
		"-leading-dash",                                                      // leading dash
		"a." + strings.Repeat("x", 100),                                      // too long + invalid char
		strings.Repeat("a", 64),                                              // length cap is 63 (1 + 62)
	}
	for _, slug := range bad {
		_, err := s.CreateView(ctx, store.ViewInput{
			Slug: slug, Name: "x", FilterJSON: []byte(`{}`),
		})
		if !errors.Is(err, store.ErrViewSlugFormat) {
			t.Errorf("slug=%q expected ErrViewSlugFormat, got %v", slug, err)
		}
	}
}

func TestViewReservedSlugRejected(t *testing.T) {
	_, s := connect(t)
	ctx := context.Background()
	for _, slug := range []string{"tree", "dashboard", "calendar", "timeline", "graph", "new", "edit", "admin", "views"} {
		_, err := s.CreateView(ctx, store.ViewInput{
			Slug: slug, Name: "x", FilterJSON: []byte(`{}`),
		})
		if !errors.Is(err, store.ErrViewSlugReserved) {
			t.Errorf("reserved slug %q should be rejected, got %v", slug, err)
		}
	}
}

func TestViewSlugCollision(t *testing.T) {
	pool, s := connect(t)
	defer pool.Close()
	ctx := context.Background()
	slug := uniqueSlug("p5j-a-collision")
	defer pool.Exec(context.Background(), `DELETE FROM projax.views WHERE slug = $1`, slug)

	if _, err := s.CreateView(ctx, store.ViewInput{Slug: slug, Name: "First"}); err != nil {
		t.Fatalf("first create: %v", err)
	}
	if _, err := s.CreateView(ctx, store.ViewInput{Slug: slug, Name: "Second"}); !errors.Is(err, store.ErrViewSlugTaken) {
		t.Errorf("duplicate slug should be ErrViewSlugTaken, got %v", err)
	}
}

func TestViewMRU(t *testing.T) {
	pool, s := connect(t)
	defer pool.Close()
	ctx := context.Background()
	a := uniqueSlug("p5j-a-mru-a")
	b := uniqueSlug("p5j-a-mru-b")
	defer pool.Exec(context.Background(), `DELETE FROM projax.views WHERE slug IN ($1, $2)`, a, b)

	if _, err := s.CreateView(ctx, store.ViewInput{Slug: a, Name: "A"}); err != nil {
		t.Fatalf("create a: %v", err)
	}
	if _, err := s.CreateView(ctx, store.ViewInput{Slug: b, Name: "B"}); err != nil {
		t.Fatalf("create b: %v", err)
	}

	// MostRecentView with no touches yet — when no view in the table has
	// last_used_at set, MRU returns nil. (Other tests may have left their
	// own touched views, so we only assert on the slugs we control.)
	if err := s.TouchView(ctx, a); err != nil {
		t.Fatalf("touch a: %v", err)
	}
	time.Sleep(20 * time.Millisecond)
	if err := s.TouchView(ctx, b); err != nil {
		t.Fatalf("touch b: %v", err)
	}

	mru, err := s.MostRecentView(ctx)
	if err != nil {
		t.Fatalf("mru: %v", err)
	}
	// Other tests' touched views may rank higher; we only assert that
	// when MRU is one of OURS, the most-recently-touched (b) wins over a.
	// To guarantee this test's signal even with contention from other
	// suites, check b's last_used_at > a's last_used_at directly.
	aV, _ := s.GetView(ctx, a)
	bV, _ := s.GetView(ctx, b)
	if aV.LastUsedAt == nil || bV.LastUsedAt == nil {
		t.Fatal("both views should have last_used_at after touch")
	}
	if !bV.LastUsedAt.After(*aV.LastUsedAt) {
		t.Errorf("b.last_used_at should be after a.last_used_at; a=%v b=%v", aV.LastUsedAt, bV.LastUsedAt)
	}
	if mru == nil {
		t.Error("MostRecentView returned nil even though touches landed")
	}
}

func TestViewReorder(t *testing.T) {
	pool, s := connect(t)
	defer pool.Close()
	ctx := context.Background()
	a := uniqueSlug("p5j-a-reorder-a")
	b := uniqueSlug("p5j-a-reorder-b")
	c := uniqueSlug("p5j-a-reorder-c")
	defer pool.Exec(context.Background(), `DELETE FROM projax.views WHERE slug IN ($1, $2, $3)`, a, b, c)

	for _, slug := range []string{a, b, c} {
		if _, err := s.CreateView(ctx, store.ViewInput{Slug: slug, Name: slug}); err != nil {
			t.Fatalf("create %s: %v", slug, err)
		}
	}
	// Reorder c → b → a.
	if err := s.ReorderViews(ctx, []string{c, b, a}); err != nil {
		t.Fatalf("reorder: %v", err)
	}
	cV, _ := s.GetView(ctx, c)
	bV, _ := s.GetView(ctx, b)
	aV, _ := s.GetView(ctx, a)
	if cV.SortOrder != 0 || bV.SortOrder != 1 || aV.SortOrder != 2 {
		t.Errorf("reorder yielded sort_orders c=%d b=%d a=%d, want 0,1,2",
			cV.SortOrder, bV.SortOrder, aV.SortOrder)
	}
}