munin/internal/store/control_test.go

package store

import (
	"context"
	"path/filepath"
	"testing"
)

// testControl öffnet eine frische Kontroll-Datenbank in einem Testverzeichnis
// — oder mit MUNIN_TEST_PG in einem eigenen PostgreSQL-Schema (siehe
// postgres_test.go).
func testControl(t *testing.T) *ControlStore {
	t.Helper()
	if pgTestEnabled() {
		return testPostgresControl(t)
	}

	c, err := OpenControl(filepath.Join(t.TempDir(), "control.db"))
	if err != nil {
		t.Fatalf("Kontroll-Datenbank konnte nicht geöffnet werden: %v", err)
	}
	t.Cleanup(func() { c.Close() })
	return c
}

func TestEnsureDefaultWorkspaceIsStable(t *testing.T) {
	c := testControl(t)
	ctx := context.Background()

	first, err := c.EnsureDefaultWorkspace(ctx, "Intern")
	if err != nil {
		t.Fatal(err)
	}
	second, err := c.EnsureDefaultWorkspace(ctx, "Anderer Name")
	if err != nil {
		t.Fatal(err)
	}

	if first.ID != second.ID {
		t.Error("EnsureDefaultWorkspace hat einen zweiten Workspace angelegt statt den bestehenden zu nehmen")
	}
}

func TestKeyIndexRouting(t *testing.T) {
	c := testControl(t)
	ctx := context.Background()

	ws, err := c.CreateWorkspace(ctx, "Team A")
	if err != nil {
		t.Fatal(err)
	}

	if err := c.IndexKey(ctx, "hash-1", ws.ID); err != nil {
		t.Fatal(err)
	}

	found, err := c.ResolveKeyWorkspace(ctx, "hash-1")
	if err != nil {
		t.Fatal(err)
	}
	if found != ws.ID {
		t.Errorf("ResolveKeyWorkspace = %q, erwartet %q", found, ws.ID)
	}

	if err := c.RemoveKeyIndex(ctx, "hash-1"); err != nil {
		t.Fatal(err)
	}
	if _, err := c.ResolveKeyWorkspace(ctx, "hash-1"); err != ErrNotFound {
		t.Errorf("nach RemoveKeyIndex: err = %v, erwartet ErrNotFound", err)
	}
}

func TestListWorkspaces(t *testing.T) {
	c := testControl(t)
	ctx := context.Background()

	a, err := c.CreateWorkspace(ctx, "Team A")
	if err != nil {
		t.Fatal(err)
	}
	b, err := c.CreateWorkspace(ctx, "Team B")
	if err != nil {
		t.Fatal(err)
	}

	ws, err := c.ListWorkspaces(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(ws) != 2 || ws[0].ID != a.ID || ws[1].ID != b.ID {
		t.Errorf("ListWorkspaces = %+v, erwartet [%q, %q] in Anlegereihenfolge", ws, a.ID, b.ID)
	}

	read, err := c.WorkspaceByID(ctx, a.ID)
	if err != nil {
		t.Fatal(err)
	}
	if read.Name != "Team A" {
		t.Errorf("WorkspaceByID.Name = %q, erwartet %q", read.Name, "Team A")
	}

	if _, err := c.WorkspaceByID(ctx, "unbekannt"); err != ErrNotFound {
		t.Errorf("unbekannte ID: err = %v, erwartet ErrNotFound", err)
	}
}

// TestWorkspaceAdmins deckt den Lebenslauf eines Workspace-Admin-Zugangs ab:
// anlegen, auflösen, zurückziehen — und dass ein anderer Workspace ihn nicht
// zurückziehen kann.
func TestWorkspaceAdmins(t *testing.T) {
	c := testControl(t)
	ctx := context.Background()

	wsA, err := c.CreateWorkspace(ctx, "A")
	if err != nil {
		t.Fatal(err)
	}
	wsB, err := c.CreateWorkspace(ctx, "B")
	if err != nil {
		t.Fatal(err)
	}

	if _, err := c.CreateWorkspaceAdmin(ctx, wsA.ID, "  ", "hash-leer"); err == nil {
		t.Error("ein Zugang ohne Namen wurde angelegt")
	}

	admin, err := c.CreateWorkspaceAdmin(ctx, wsA.ID, "Erika", "hash-1")
	if err != nil {
		t.Fatal(err)
	}

	found, err := c.ResolveWorkspaceAdminHash(ctx, "hash-1")
	if err != nil || found.ID != admin.ID || found.WorkspaceID != wsA.ID {
		t.Fatalf("ResolveWorkspaceAdminHash = %+v, %v", found, err)
	}

	if err := c.RevokeWorkspaceAdmin(ctx, wsB.ID, admin.ID); err != ErrNotFound {
		t.Errorf("Zurückziehen aus fremdem Workspace: err = %v, erwartet ErrNotFound", err)
	}

	if err := c.RevokeWorkspaceAdmin(ctx, wsA.ID, admin.ID); err != nil {
		t.Fatal(err)
	}
	if _, err := c.ResolveWorkspaceAdminHash(ctx, "hash-1"); err != ErrNotFound {
		t.Errorf("zurückgezogener Zugang löst noch auf: err = %v", err)
	}

	// Die Zeile bleibt für die Verwaltung und das Protokoll erhalten.
	read, err := c.WorkspaceAdminByID(ctx, admin.ID)
	if err != nil || !read.Revoked() {
		t.Errorf("WorkspaceAdminByID = %+v, %v — erwartet zurückgezogen", read, err)
	}
}

// TestWorkspaceAdminsVanishWithWorkspace: Wird ein Workspace gelöscht, fallen
// seine Workspace-Admins mit weg (ON DELETE CASCADE) — sonst bliebe eine
// Sitzung auf einen nicht mehr vorhandenen Workspace übrig.
func TestWorkspaceAdminsVanishWithWorkspace(t *testing.T) {
	c := testControl(t)
	ctx := context.Background()

	ws, err := c.CreateWorkspace(ctx, "Weg")
	if err != nil {
		t.Fatal(err)
	}
	admin, err := c.CreateWorkspaceAdmin(ctx, ws.ID, "Erika", "hash-weg")
	if err != nil {
		t.Fatal(err)
	}

	if err := c.DeleteWorkspace(ctx, ws.ID); err != nil {
		t.Fatal(err)
	}
	if _, err := c.WorkspaceAdminByID(ctx, admin.ID); err != ErrNotFound {
		t.Errorf("Workspace-Admin nach dem Löschen des Workspace: err = %v, erwartet ErrNotFound", err)
	}
}