sandrodach
7802eb2cf0
MindSift CI & Docker Release / Build, Test in Container & Push (push) Successful in 1m2s
434 lines
15 KiB
Go
434 lines
15 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/sandrodach/mindsift/internal/auth"
|
|
"github.com/sandrodach/mindsift/internal/config"
|
|
"github.com/sandrodach/mindsift/internal/domain"
|
|
"github.com/sandrodach/mindsift/internal/storage"
|
|
"github.com/sandrodach/mindsift/internal/ws"
|
|
)
|
|
|
|
func setupTestServer(t *testing.T) (*Server, *storage.Store, string) {
|
|
t.Helper()
|
|
dbPath := filepath.Join(t.TempDir(), "test_mindsift.db")
|
|
store, err := storage.NewStore(dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create test store: %v", err)
|
|
}
|
|
t.Cleanup(func() {
|
|
_ = store.Close()
|
|
})
|
|
|
|
user, err := store.EnsureDefaultUser()
|
|
if err != nil {
|
|
t.Fatalf("failed to ensure test user: %v", err)
|
|
}
|
|
_ = store.SeedStarterContent(user)
|
|
|
|
cfg := &config.Config{
|
|
Port: "8080",
|
|
DatabasePath: dbPath,
|
|
JWTSecret: "test-jwt-secret-key",
|
|
AllowRegistration: false,
|
|
}
|
|
hub := ws.NewHub()
|
|
srv := NewServer(cfg, store, hub, nil)
|
|
|
|
token, err := auth.GenerateToken(cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
|
|
if err != nil {
|
|
t.Fatalf("failed to generate token: %v", err)
|
|
}
|
|
|
|
return srv, store, token
|
|
}
|
|
|
|
func TestFirstBootSetupAndInviteRegistrationAndNonNullSlices(t *testing.T) {
|
|
dbPath := filepath.Join(t.TempDir(), "fresh_mindsift.db")
|
|
store, err := storage.NewStore(dbPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to create fresh store: %v", err)
|
|
}
|
|
defer store.Close()
|
|
|
|
cfg := &config.Config{
|
|
Port: "8080",
|
|
DatabasePath: dbPath,
|
|
JWTSecret: "test-jwt-secret-key",
|
|
AllowRegistration: false,
|
|
}
|
|
srv := NewServer(cfg, store, ws.NewHub(), nil)
|
|
router := srv.Router()
|
|
|
|
// 1. Fresh DB must report needsSetup = true
|
|
req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/status", nil)
|
|
rec := httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK from /api/v1/auth/status, got %d", rec.Code)
|
|
}
|
|
var statusResp struct {
|
|
NeedsSetup bool `json:"needsSetup"`
|
|
AllowRegistration bool `json:"allowRegistration"`
|
|
InstanceName string `json:"instanceName"`
|
|
}
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &statusResp)
|
|
if !statusResp.NeedsSetup {
|
|
t.Fatalf("expected needsSetup=true on fresh database, got false")
|
|
}
|
|
|
|
// 2. Complete First-Boot Setup (without sample data)
|
|
setupBody := []byte(`{
|
|
"email": "owner@example.com",
|
|
"password": "secretpassword",
|
|
"displayName": "Server Owner",
|
|
"instanceName": "My MindSift",
|
|
"allowRegistration": false,
|
|
"sharingMode": "teams_only",
|
|
"seedSampleData": false
|
|
}`)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/setup", bytes.NewReader(setupBody))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created from /api/v1/auth/setup, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var setupRes struct {
|
|
Token string `json:"token"`
|
|
User domain.User `json:"user"`
|
|
}
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &setupRes)
|
|
if setupRes.User.Role != "admin" || setupRes.Token == "" {
|
|
t.Fatalf("expected admin user and token, got %+v", setupRes)
|
|
}
|
|
|
|
// 3. Verify empty endpoints return [] and never null (preventing React crashes)
|
|
arrayEndpoints := []string{
|
|
"/api/v1/task-lists",
|
|
"/api/v1/tasks",
|
|
"/api/v1/organizations",
|
|
"/api/v1/teams",
|
|
"/api/v1/spaces",
|
|
"/api/v1/lists",
|
|
}
|
|
for _, ep := range arrayEndpoints {
|
|
req = httptest.NewRequest(http.MethodGet, ep, nil)
|
|
req.Header.Set("Authorization", "Bearer "+setupRes.Token)
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("GET %s returned %d", ep, rec.Code)
|
|
}
|
|
trimmed := strings.TrimSpace(rec.Body.String())
|
|
if trimmed == "null" || !strings.HasPrefix(trimmed, "[") {
|
|
t.Fatalf("GET %s returned %q instead of JSON array []", ep, trimmed)
|
|
}
|
|
}
|
|
|
|
// 4. Public registration without invite must be rejected (403)
|
|
regBody := []byte(`{"email":"member@example.com","password":"password123","displayName":"Member"}`)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/register", bytes.NewReader(regBody))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusForbidden {
|
|
t.Fatalf("expected 403 Forbidden when registration is disabled, got %d", rec.Code)
|
|
}
|
|
|
|
// 5. Create an Invite as Admin and register with that Invite Code
|
|
invBody := []byte(`{"role":"team_admin","validDays":7}`)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/admin/invites", bytes.NewReader(invBody))
|
|
req.Header.Set("Authorization", "Bearer "+setupRes.Token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created for invite, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var createdInvite domain.UserInvite
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &createdInvite)
|
|
if createdInvite.Code == "" {
|
|
t.Fatalf("expected invite code, got empty")
|
|
}
|
|
|
|
regWithInviteBody, _ := json.Marshal(map[string]string{
|
|
"email": "invited@example.com",
|
|
"password": "password123",
|
|
"displayName": "Invited Team Admin",
|
|
"inviteCode": createdInvite.Code,
|
|
})
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/register", bytes.NewReader(regWithInviteBody))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created when registering with valid invite code, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var invitedRes struct {
|
|
User domain.User `json:"user"`
|
|
}
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &invitedRes)
|
|
if invitedRes.User.Role != "team_admin" {
|
|
t.Fatalf("expected invited user to receive role 'team_admin', got %q", invitedRes.User.Role)
|
|
}
|
|
}
|
|
|
|
func TestConcurrentInitialLoadAndListsNoDeadlock(t *testing.T) {
|
|
srv, _, token := setupTestServer(t)
|
|
router := srv.Router()
|
|
|
|
endpoints := []string{
|
|
"/api/v1/auth/me",
|
|
"/api/v1/triage/deck",
|
|
"/api/v1/lists",
|
|
"/api/v1/spaces",
|
|
"/api/v1/tasks",
|
|
"/api/v1/documents",
|
|
}
|
|
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 3; i++ {
|
|
for _, ep := range endpoints {
|
|
wg.Add(1)
|
|
go func(path string) {
|
|
defer wg.Done()
|
|
req := httptest.NewRequest(http.MethodGet, path, nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
rec := httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusOK {
|
|
t.Errorf("GET %s returned %d: %s", path, rec.Code, rec.Body.String())
|
|
}
|
|
}(ep)
|
|
}
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func TestQuickDumpToTriageAndDirectTargets(t *testing.T) {
|
|
srv, store, token := setupTestServer(t)
|
|
router := srv.Router()
|
|
|
|
// Verify stale token from non-existent user is rejected (401)
|
|
staleToken, _ := auth.GenerateToken("test-jwt-secret-key", "usr_non_existent", "old@mindsift.local", "Old")
|
|
req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
|
|
req.Header.Set("Authorization", "Bearer "+staleToken)
|
|
rec := httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusUnauthorized {
|
|
t.Fatalf("expected 401 Unauthorized for stale token, got %d", rec.Code)
|
|
}
|
|
|
|
// 1. Capture Quick Dump (default target: inbox)
|
|
dumpPayload := map[string]string{
|
|
"content": "Schneller Quick Dump Testgedanke #test",
|
|
"priority": "high",
|
|
"target": "inbox",
|
|
}
|
|
body, _ := json.Marshal(dumpPayload)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/inbox", bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created for Quick Dump, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
|
|
var createdDump domain.Thought
|
|
if err := json.Unmarshal(rec.Body.Bytes(), &createdDump); err != nil {
|
|
t.Fatalf("failed to decode created dump: %v", err)
|
|
}
|
|
if createdDump.Status != domain.StatusInbox {
|
|
t.Fatalf("expected status 'inbox', got %q", createdDump.Status)
|
|
}
|
|
|
|
// 2. Capture Direct Task (target: task)
|
|
taskPayload := map[string]string{
|
|
"content": "Direkte Aufgabe ohne Triage",
|
|
"priority": "urgent",
|
|
"target": "task",
|
|
"dueDate": "2026-11-01",
|
|
}
|
|
body, _ = json.Marshal(taskPayload)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/inbox", bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created for Direct Task, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var createdTask domain.Thought
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &createdTask)
|
|
if createdTask.Status != domain.StatusConverted || createdTask.ConvertedType != "task" {
|
|
t.Fatalf("expected converted task, got status=%q type=%q", createdTask.Status, createdTask.ConvertedType)
|
|
}
|
|
|
|
// 3. Capture Direct List Item (target: list_item)
|
|
defUser, _ := store.EnsureDefaultUser()
|
|
lists, err := store.GetAllListsForUser(defUser.ID)
|
|
if err != nil || len(lists) == 0 {
|
|
t.Fatalf("expected starter lists, got len=%d err=%v", len(lists), err)
|
|
}
|
|
targetListID := lists[0].ID
|
|
|
|
listPayload := map[string]string{
|
|
"content": "Frische Haferflocken",
|
|
"target": "list_item",
|
|
"targetListId": targetListID,
|
|
}
|
|
body, _ = json.Marshal(listPayload)
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/inbox", bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created for Direct List Item, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var createdListItemThought domain.Thought
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &createdListItemThought)
|
|
if createdListItemThought.ConvertedType != "list_item" || createdListItemThought.ConvertedRefID == "" {
|
|
t.Fatalf("expected converted list_item, got %+v", createdListItemThought)
|
|
}
|
|
|
|
// 4. Swipe Triage card to Task
|
|
triagePayload := map[string]string{
|
|
"action": "keep",
|
|
"convertTo": "task",
|
|
}
|
|
body, _ = json.Marshal(triagePayload)
|
|
req = httptest.NewRequest(http.MethodPatch, "/api/v1/triage/"+createdDump.ID, bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for triage action, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestNewFullFeatures(t *testing.T) {
|
|
srv, _, token := setupTestServer(t)
|
|
router := srv.Router()
|
|
|
|
// 1. Test TaskLists: Create & Get
|
|
taskListPayload := map[string]string{
|
|
"title": "Homelab & Docker",
|
|
"icon": "🐳",
|
|
"color": "#3b82f6",
|
|
}
|
|
body, _ := json.Marshal(taskListPayload)
|
|
req := httptest.NewRequest(http.MethodPost, "/api/v1/task-lists", bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec := httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusCreated {
|
|
t.Fatalf("expected 201 Created for TaskList, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var createdTaskList domain.TaskList
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &createdTaskList)
|
|
if createdTaskList.Title != "Homelab & Docker" {
|
|
t.Fatalf("expected task list title 'Homelab & Docker', got %q", createdTaskList.Title)
|
|
}
|
|
|
|
req = httptest.NewRequest(http.MethodGet, "/api/v1/task-lists", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for GET /api/v1/task-lists, got %d", rec.Code)
|
|
}
|
|
|
|
// 2. Test User Settings: Update Multi-Channel Alarms & Profile
|
|
settingsPayload := map[string]interface{}{
|
|
"displayName": "Admin User",
|
|
"alarmChannels": []string{"email", "discord", "webhook"},
|
|
"alarmEmail": "alarms@example.com",
|
|
"discordWebhookUrl": "https://discord.com/api/webhooks/test/123",
|
|
"customWebhookUrl": "https://ntfy.sh/my-topic",
|
|
"notifyBeforeMinutes": 15,
|
|
}
|
|
body, _ = json.Marshal(settingsPayload)
|
|
req = httptest.NewRequest(http.MethodPatch, "/api/v1/auth/settings", bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for PATCH /api/v1/auth/settings, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var updatedUser domain.User
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &updatedUser)
|
|
if len(updatedUser.AlarmChannels) != 3 || updatedUser.AlarmEmail != "alarms@example.com" {
|
|
t.Fatalf("expected 3 alarm channels and alarmEmail, got %+v", updatedUser)
|
|
}
|
|
|
|
// 3. Test Admin routes (default user is admin)
|
|
req = httptest.NewRequest(http.MethodGet, "/api/v1/admin/users", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for GET /api/v1/admin/users, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
|
|
req = httptest.NewRequest(http.MethodGet, "/api/v1/admin/settings", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for GET /api/v1/admin/settings, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
|
|
// 4. Test Kanban & Task details update
|
|
taskUpdatePayload := map[string]interface{}{
|
|
"kanbanStatus": "in_progress",
|
|
"notes": "Detailnotizen für die Aufgabe",
|
|
"taskListId": createdTaskList.ID,
|
|
}
|
|
req = httptest.NewRequest(http.MethodPost, "/api/v1/inbox", bytes.NewReader([]byte(`{"content":"Kanban Task Test","target":"task"}`)))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
var taskThought domain.Thought
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &taskThought)
|
|
|
|
body, _ = json.Marshal(taskUpdatePayload)
|
|
req = httptest.NewRequest(http.MethodPatch, "/api/v1/thoughts/"+taskThought.ID, bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rec = httptest.NewRecorder()
|
|
router.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 OK for PATCH /api/v1/thoughts/{id}, got %d: %s", rec.Code, rec.Body.String())
|
|
}
|
|
var updatedThought domain.Thought
|
|
_ = json.Unmarshal(rec.Body.Bytes(), &updatedThought)
|
|
if updatedThought.KanbanStatus != "in_progress" || updatedThought.Notes != "Detailnotizen für die Aufgabe" {
|
|
t.Fatalf("expected updated kanbanStatus and notes, got %+v", updatedThought)
|
|
}
|
|
}
|