Skip to content

The only tool you need to know what is happening and how to fix it.

13.1 KB
Raw Blame
//go:build !telemetry_ch

package backfill

import (
	"database/sql"
	"encoding/json"
	"strings"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/tracewayapp/lit/v2"
	"github.com/tracewayapp/traceway/backend/app/db"
	"github.com/tracewayapp/traceway/backend/app/models"
	_ "modernc.org/sqlite"
)

func setup(t *testing.T) {
	t.Helper()

	mainDB, err := sql.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("open main db: %v", err)
	}
	mainDB.SetMaxOpenConns(1)

	ddl := []string{
		`CREATE TABLE projects (id TEXT PRIMARY KEY, name TEXT NOT NULL, organization_id INTEGER)`,
		`CREATE TABLE widget_groups (id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT NOT NULL, name TEXT NOT NULL, description TEXT DEFAULT '', is_default INTEGER NOT NULL DEFAULT 0, created_by INTEGER, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL)`,
		`CREATE TABLE widget_group_widgets (id INTEGER PRIMARY KEY AUTOINCREMENT, widget_group_id INTEGER NOT NULL, title TEXT NOT NULL, widget_type TEXT NOT NULL, config TEXT NOT NULL DEFAULT '{}', position INTEGER NOT NULL DEFAULT 0, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL)`,
		`CREATE TABLE starred_widgets (id INTEGER PRIMARY KEY AUTOINCREMENT, widget_id INTEGER NOT NULL UNIQUE, position INTEGER NOT NULL DEFAULT 0, col_span INTEGER NOT NULL DEFAULT 1, size TEXT NOT NULL DEFAULT 'sm', created_at DATETIME NOT NULL)`,
		`CREATE TABLE dashboards (id INTEGER PRIMARY KEY AUTOINCREMENT, organization_id INTEGER NOT NULL, name TEXT NOT NULL, description TEXT NOT NULL DEFAULT '', definition TEXT NOT NULL DEFAULT '{}', template_key TEXT, created_by INTEGER, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL)`,
		`CREATE TABLE project_dashboards (id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT NOT NULL, dashboard_id INTEGER NOT NULL, position INTEGER NOT NULL DEFAULT 0, created_at DATETIME NOT NULL, UNIQUE(project_id, dashboard_id))`,
		`CREATE TABLE starred_dashboard_widgets (id INTEGER PRIMARY KEY AUTOINCREMENT, project_id TEXT NOT NULL, dashboard_id INTEGER NOT NULL, widget_id TEXT NOT NULL, position INTEGER NOT NULL DEFAULT 0, col_span INTEGER NOT NULL DEFAULT 1, size TEXT NOT NULL DEFAULT 'sm', created_at DATETIME NOT NULL, UNIQUE(project_id, dashboard_id, widget_id))`,
		`CREATE TABLE backfill_runs (name TEXT PRIMARY KEY, ran_at DATETIME NOT NULL)`,
		`CREATE UNIQUE INDEX idx_dashboards_org_lower_name ON dashboards(organization_id, LOWER(name))`,
	}
	for _, stmt := range ddl {
		if _, err := mainDB.Exec(stmt); err != nil {
			t.Fatalf("ddl: %v", err)
		}
	}

	prevDB, prevDriver := db.DB, db.Driver
	db.DB = mainDB
	db.Driver = lit.SQLite
	models.Init(db.Driver)

	t.Cleanup(func() {
		mainDB.Close()
		db.DB = prevDB
		db.Driver = prevDriver
	})
}

func seedGroup(t *testing.T, projectId uuid.UUID, name string, isDefault bool, widgetTitles []string) []int {
	t.Helper()
	now := time.Now().UTC()
	group := models.WidgetGroup{
		ProjectId: projectId,
		Name:      name,
		IsDefault: isDefault,
		CreatedAt: now,
		UpdatedAt: now,
	}
	groupId, err := lit.Insert(db.DB, &group)
	if err != nil {
		t.Fatalf("seed widget_group: %v", err)
	}
	widgetIds := make([]int, 0, len(widgetTitles))
	for i, title := range widgetTitles {
		w := models.WidgetGroupWidget{
			WidgetGroupId: groupId,
			Title:         title,
			WidgetType:    "line_chart",
			Config:        models.JSONText(`{"sources":[{"type":"metric","name":"cpu.used_pcnt","aggregation":"avg"}]}`),
			Position:      i,
			CreatedAt:     now,
			UpdatedAt:     now,
		}
		id, err := lit.Insert(db.DB, &w)
		if err != nil {
			t.Fatalf("seed widget: %v", err)
		}
		widgetIds = append(widgetIds, id)
	}
	return widgetIds
}

func TestBackfillConvertsGroupsToDashboards(t *testing.T) {
	setup(t)

	projectId := uuid.New()
	if _, err := db.DB.Exec(`INSERT INTO projects (id, name, organization_id) VALUES (?, 'p1', 7)`, projectId.String()); err != nil {
		t.Fatalf("seed project: %v", err)
	}

	customIds := seedGroup(t, projectId, "Custom", false, []string{"A", "B"})
	seedGroup(t, projectId, "CPU / Mem", true, []string{"CPU Usage"})

	star := models.StarredWidget{WidgetId: customIds[1], Position: 3, ColSpan: 2, Size: "md", CreatedAt: time.Now().UTC()}
	if err := db.DB.QueryRow(`INSERT INTO starred_widgets (widget_id, position, col_span, size, created_at) VALUES (?, ?, ?, ?, ?) RETURNING id`,
		star.WidgetId, star.Position, star.ColSpan, star.Size, star.CreatedAt).Scan(&star.Id); err != nil {
		t.Fatalf("seed starred: %v", err)
	}

	if err := RunDashboards(); err != nil {
		t.Fatalf("RunDashboards: %v", err)
	}

	dashboards, err := lit.SelectNamed[models.Dashboard](db.DB, "SELECT id, organization_id, name, description, definition, template_key, created_by, created_at, updated_at FROM dashboards ORDER BY id ASC", lit.P{})
	if err != nil {
		t.Fatalf("select dashboards: %v", err)
	}
	if len(dashboards) != 2 {
		t.Fatalf("expected 2 dashboards, got %d", len(dashboards))
	}
	for _, d := range dashboards {
		if d.OrganizationId != 7 {
			t.Errorf("dashboard %q has org %d, want 7", d.Name, d.OrganizationId)
		}
	}

	assignments, err := lit.SelectNamed[models.ProjectDashboard](db.DB, "SELECT id, project_id, dashboard_id, position, created_at FROM project_dashboards ORDER BY position ASC", lit.P{})
	if err != nil {
		t.Fatalf("select assignments: %v", err)
	}
	if len(assignments) != 2 {
		t.Fatalf("expected 2 assignments, got %d", len(assignments))
	}

	byId := map[int]*models.Dashboard{}
	for _, d := range dashboards {
		byId[d.Id] = d
	}
	if byId[assignments[0].DashboardId].Name != "CPU / Mem" {
		t.Errorf("first tab should be the default group, got %q", byId[assignments[0].DashboardId].Name)
	}
	if byId[assignments[1].DashboardId].Name != "Custom" {
		t.Errorf("second tab should be Custom, got %q", byId[assignments[1].DashboardId].Name)
	}

	var customDef models.DashboardDefinition
	customDashboardId := assignments[1].DashboardId
	if err := json.Unmarshal(byId[customDashboardId].Definition, &customDef); err != nil {
		t.Fatalf("unmarshal definition: %v", err)
	}
	if len(customDef.Widgets) != 2 || customDef.Widgets[0].Title != "A" || customDef.Widgets[1].Title != "B" {
		t.Fatalf("unexpected widgets in Custom definition: %+v", customDef.Widgets)
	}
	for _, w := range customDef.Widgets {
		if len(w.Id) != 10 || w.Id[:2] != "w_" {
			t.Errorf("widget id %q not in expected format", w.Id)
		}
	}

	starred, err := lit.SelectNamed[models.StarredDashboardWidget](db.DB, "SELECT id, project_id, dashboard_id, widget_id, position, col_span, size, created_at FROM starred_dashboard_widgets", lit.P{})
	if err != nil {
		t.Fatalf("select starred: %v", err)
	}
	if len(starred) != 1 {
		t.Fatalf("expected 1 starred widget, got %d", len(starred))
	}
	if starred[0].DashboardId != customDashboardId || starred[0].WidgetId != customDef.Widgets[1].Id {
		t.Errorf("star should reference widget B of Custom, got dashboard %d widget %s", starred[0].DashboardId, starred[0].WidgetId)
	}
	if starred[0].Position != 3 || starred[0].ColSpan != 2 || starred[0].Size != "md" {
		t.Errorf("star layout not preserved: %+v", starred[0])
	}

	if err := RunDashboards(); err != nil {
		t.Fatalf("second RunDashboards: %v", err)
	}
	again, err := lit.SelectNamed[models.Dashboard](db.DB, "SELECT id, organization_id, name, description, definition, template_key, created_by, created_at, updated_at FROM dashboards", lit.P{})
	if err != nil {
		t.Fatalf("select dashboards after rerun: %v", err)
	}
	if len(again) != 2 {
		t.Fatalf("backfill is not idempotent: got %d dashboards after rerun", len(again))
	}
}

func TestBackfillSurvivesLegacyNullsAndLongNames(t *testing.T) {
	setup(t)

	projectId := uuid.New()
	if _, err := db.DB.Exec(`INSERT INTO projects (id, name, organization_id) VALUES (?, 'p1', 3)`, projectId.String()); err != nil {
		t.Fatalf("seed project: %v", err)
	}

	longName := strings.Repeat("x", 150)
	now := time.Now().UTC()
	if _, err := db.DB.Exec(
		`INSERT INTO widget_groups (project_id, name, description, is_default, created_at, updated_at) VALUES (?, ?, NULL, 0, ?, ?)`,
		projectId.String(), longName, now, now,
	); err != nil {
		t.Fatalf("seed legacy group: %v", err)
	}
	var groupId int
	if err := db.DB.QueryRow(`SELECT id FROM widget_groups`).Scan(&groupId); err != nil {
		t.Fatalf("read group id: %v", err)
	}
	if _, err := db.DB.Exec(
		`INSERT INTO widget_group_widgets (widget_group_id, title, widget_type, config, position, created_at, updated_at) VALUES (?, 'W', 'line_chart', '{"sources":[{"type":"metric","name":"m","aggregation":"avg"}]}', 0, ?, ?)`,
		groupId, now, now,
	); err != nil {
		t.Fatalf("seed widget: %v", err)
	}

	if err := RunDashboards(); err != nil {
		t.Fatalf("RunDashboards: %v", err)
	}

	dashboards, err := lit.SelectNamed[models.Dashboard](db.DB, "SELECT id, organization_id, name, description, definition, template_key, created_by, created_at, updated_at FROM dashboards", lit.P{})
	if err != nil {
		t.Fatalf("select dashboards: %v", err)
	}
	if len(dashboards) != 1 {
		t.Fatalf("expected 1 dashboard, got %d", len(dashboards))
	}
	if len(dashboards[0].Name) != 100 {
		t.Errorf("name should be truncated to 100 chars, got %d", len(dashboards[0].Name))
	}
	if dashboards[0].Description != "" {
		t.Errorf("NULL description should become empty string, got %q", dashboards[0].Description)
	}
}

func TestBackfillSkipsWhenNoGroups(t *testing.T) {
	setup(t)
	if err := RunDashboards(); err != nil {
		t.Fatalf("RunDashboards: %v", err)
	}
	var n int
	if err := db.DB.QueryRow("SELECT count(*) FROM dashboards").Scan(&n); err != nil {
		t.Fatalf("count: %v", err)
	}
	if n != 0 {
		t.Fatalf("expected no dashboards, got %d", n)
	}
	if err := db.DB.QueryRow("SELECT count(*) FROM backfill_runs WHERE name = 'dashboards'").Scan(&n); err != nil {
		t.Fatalf("count marker: %v", err)
	}
	if n != 1 {
		t.Fatalf("expected marker row even with no groups, got %d", n)
	}
}

func TestBackfillMarkerPreventsResurrectionAfterDeletes(t *testing.T) {
	setup(t)

	projectId := uuid.New()
	if _, err := db.DB.Exec(`INSERT INTO projects (id, name, organization_id) VALUES (?, 'p1', 7)`, projectId.String()); err != nil {
		t.Fatalf("seed project: %v", err)
	}
	seedGroup(t, projectId, "Custom", false, []string{"A"})

	if err := RunDashboards(); err != nil {
		t.Fatalf("RunDashboards: %v", err)
	}
	var n int
	if err := db.DB.QueryRow("SELECT count(*) FROM dashboards").Scan(&n); err != nil {
		t.Fatalf("count: %v", err)
	}
	if n != 1 {
		t.Fatalf("expected 1 dashboard after first run, got %d", n)
	}

	if _, err := db.DB.Exec("DELETE FROM starred_dashboard_widgets"); err != nil {
		t.Fatalf("delete starred: %v", err)
	}
	if _, err := db.DB.Exec("DELETE FROM project_dashboards"); err != nil {
		t.Fatalf("delete assignments: %v", err)
	}
	if _, err := db.DB.Exec("DELETE FROM dashboards"); err != nil {
		t.Fatalf("delete dashboards: %v", err)
	}

	if err := RunDashboards(); err != nil {
		t.Fatalf("second RunDashboards: %v", err)
	}
	if err := db.DB.QueryRow("SELECT count(*) FROM dashboards").Scan(&n); err != nil {
		t.Fatalf("count after rerun: %v", err)
	}
	if n != 0 {
		t.Fatalf("deleted dashboards were resurrected: got %d", n)
	}
	if err := db.DB.QueryRow("SELECT count(*) FROM backfill_runs WHERE name = 'dashboards'").Scan(&n); err != nil {
		t.Fatalf("count marker: %v", err)
	}
	if n != 1 {
		t.Fatalf("expected exactly 1 marker row, got %d", n)
	}
}

func TestBackfillDedupesNamesWithinOrg(t *testing.T) {
	setup(t)

	p1 := uuid.MustParse("00000000-0000-0000-0000-000000000001")
	p2 := uuid.MustParse("00000000-0000-0000-0000-000000000002")
	p3 := uuid.MustParse("00000000-0000-0000-0000-000000000003")
	for _, p := range []struct {
		id   uuid.UUID
		name string
	}{{p1, "Alpha"}, {p2, "Beta"}, {p3, "Beta"}} {
		if _, err := db.DB.Exec(`INSERT INTO projects (id, name, organization_id) VALUES (?, ?, 9)`, p.id.String(), p.name); err != nil {
			t.Fatalf("seed project: %v", err)
		}
	}
	seedGroup(t, p1, "CPU / Mem", false, []string{"A"})
	seedGroup(t, p2, "cpu / mem", false, []string{"B"})
	seedGroup(t, p3, "CPU / Mem", false, []string{"C"})

	if err := RunDashboards(); err != nil {
		t.Fatalf("RunDashboards: %v", err)
	}

	assignments, err := lit.SelectNamed[models.ProjectDashboard](db.DB, "SELECT id, project_id, dashboard_id, position, created_at FROM project_dashboards", lit.P{})
	if err != nil {
		t.Fatalf("select assignments: %v", err)
	}
	dashboards, err := lit.SelectNamed[models.Dashboard](db.DB, "SELECT id, organization_id, name, description, definition, template_key, created_by, created_at, updated_at FROM dashboards", lit.P{})
	if err != nil {
		t.Fatalf("select dashboards: %v", err)
	}
	if len(dashboards) != 3 {
		t.Fatalf("expected 3 dashboards, got %d", len(dashboards))
	}

	nameById := map[int]string{}
	for _, d := range dashboards {
		nameById[d.Id] = d.Name
	}
	nameByProject := map[uuid.UUID]string{}
	for _, a := range assignments {
		nameByProject[a.ProjectId] = nameById[a.DashboardId]
	}

	if nameByProject[p1] != "CPU / Mem" {
		t.Errorf("first project should keep the plain name, got %q", nameByProject[p1])
	}
	if nameByProject[p2] != "cpu / mem (Beta)" {
		t.Errorf("case-insensitive collision should get the project suffix, got %q", nameByProject[p2])
	}
	if nameByProject[p3] != "CPU / Mem (Beta) 2" {
		t.Errorf("repeat collision on the same project name should get a numeral, got %q", nameByProject[p3])
	}
}