add tests

tests/mocks/auth_middleware_mock.go

@@ -0,0 +1,60 @@
+package mocks
+
+import (
+	"acc-server-manager/local/middleware"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/google/uuid"
+)
+
+// MockAuthMiddleware provides a test implementation of AuthMiddleware
+// that can be used as a drop-in replacement for the real AuthMiddleware
+type MockAuthMiddleware struct{}
+
+// NewMockAuthMiddleware creates a new MockAuthMiddleware
+func NewMockAuthMiddleware() *MockAuthMiddleware {
+	return &MockAuthMiddleware{}
+}
+
+// Authenticate is a middleware that allows all requests without authentication for testing
+func (m *MockAuthMiddleware) Authenticate(ctx *fiber.Ctx) error {
+	// Set a mock user ID in context
+	mockUserID := uuid.New().String()
+	ctx.Locals("userID", mockUserID)
+
+	// Set mock user info
+	mockUserInfo := &middleware.CachedUserInfo{
+		UserID:      mockUserID,
+		Username:    "test_user",
+		RoleName:    "Admin", // Admin role to bypass permission checks
+		Permissions: map[string]bool{"*": true},
+		CachedAt:    time.Now(),
+	}
+
+	ctx.Locals("userInfo", mockUserInfo)
+	ctx.Locals("authTime", time.Now())
+
+	return ctx.Next()
+}
+
+// HasPermission is a middleware that allows all permission checks to pass for testing
+func (m *MockAuthMiddleware) HasPermission(requiredPermission string) fiber.Handler {
+	return func(ctx *fiber.Ctx) error {
+		return ctx.Next()
+	}
+}
+
+// AuthRateLimit is a test implementation that allows all requests
+func (m *MockAuthMiddleware) AuthRateLimit() fiber.Handler {
+	return func(ctx *fiber.Ctx) error {
+		return ctx.Next()
+	}
+}
+
+// RequireHTTPS is a test implementation that allows all HTTP requests
+func (m *MockAuthMiddleware) RequireHTTPS() fiber.Handler {
+	return func(ctx *fiber.Ctx) error {
+		return ctx.Next()
+	}
+}

tests/mocks/repository_mock.go

@@ -0,0 +1,131 @@
+package mocks
+
+import (
+	"acc-server-manager/local/model"
+	"context"
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+// MockConfigRepository provides a mock implementation of ConfigRepository
+type MockConfigRepository struct {
+	configs          map[string]*model.Config
+	shouldFailGet    bool
+	shouldFailUpdate bool
+}
+
+func NewMockConfigRepository() *MockConfigRepository {
+	return &MockConfigRepository{
+		configs: make(map[string]*model.Config),
+	}
+}
+
+// UpdateConfig mocks the UpdateConfig method
+func (m *MockConfigRepository) UpdateConfig(ctx context.Context, config *model.Config) *model.Config {
+	if m.shouldFailUpdate {
+		return nil
+	}
+
+	if config.ID == uuid.Nil {
+		config.ID = uuid.New()
+	}
+
+	key := config.ServerID.String() + "_" + config.ConfigFile
+	m.configs[key] = config
+	return config
+}
+
+// SetShouldFailUpdate configures the mock to fail on UpdateConfig calls
+func (m *MockConfigRepository) SetShouldFailUpdate(shouldFail bool) {
+	m.shouldFailUpdate = shouldFail
+}
+
+// GetConfig retrieves a config by server ID and config file
+func (m *MockConfigRepository) GetConfig(serverID uuid.UUID, configFile string) *model.Config {
+	key := serverID.String() + "_" + configFile
+	return m.configs[key]
+}
+
+// MockServerRepository provides a mock implementation of ServerRepository
+type MockServerRepository struct {
+	servers       map[uuid.UUID]*model.Server
+	shouldFailGet bool
+}
+
+func NewMockServerRepository() *MockServerRepository {
+	return &MockServerRepository{
+		servers: make(map[uuid.UUID]*model.Server),
+	}
+}
+
+// GetByID mocks the GetByID method
+func (m *MockServerRepository) GetByID(ctx context.Context, id interface{}) (*model.Server, error) {
+	if m.shouldFailGet {
+		return nil, errors.New("server not found")
+	}
+
+	var serverID uuid.UUID
+	var err error
+
+	switch v := id.(type) {
+	case string:
+		serverID, err = uuid.Parse(v)
+		if err != nil {
+			return nil, errors.New("invalid server ID format")
+		}
+	case uuid.UUID:
+		serverID = v
+	default:
+		return nil, errors.New("invalid server ID type")
+	}
+
+	server, exists := m.servers[serverID]
+	if !exists {
+		return nil, errors.New("server not found")
+	}
+
+	return server, nil
+}
+
+// AddServer adds a server to the mock repository
+func (m *MockServerRepository) AddServer(server *model.Server) {
+	m.servers[server.ID] = server
+}
+
+// SetShouldFailGet configures the mock to fail on GetByID calls
+func (m *MockServerRepository) SetShouldFailGet(shouldFail bool) {
+	m.shouldFailGet = shouldFail
+}
+
+// MockServerService provides a mock implementation of ServerService
+type MockServerService struct {
+	startRuntimeCalled bool
+	startRuntimeServer *model.Server
+}
+
+func NewMockServerService() *MockServerService {
+	return &MockServerService{}
+}
+
+// StartAccServerRuntime mocks the StartAccServerRuntime method
+func (m *MockServerService) StartAccServerRuntime(server *model.Server) {
+	m.startRuntimeCalled = true
+	m.startRuntimeServer = server
+}
+
+// WasStartRuntimeCalled returns whether StartAccServerRuntime was called
+func (m *MockServerService) WasStartRuntimeCalled() bool {
+	return m.startRuntimeCalled
+}
+
+// GetStartRuntimeServer returns the server passed to StartAccServerRuntime
+func (m *MockServerService) GetStartRuntimeServer() *model.Server {
+	return m.startRuntimeServer
+}
+
+// Reset resets the mock state
+func (m *MockServerService) Reset() {
+	m.startRuntimeCalled = false
+	m.startRuntimeServer = nil
+}

tests/mocks/state_history_mock.go

@@ -0,0 +1,376 @@
+package mocks
+
+import (
+	"acc-server-manager/local/model"
+	"context"
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+// MockStateHistoryRepository provides a mock implementation of StateHistoryRepository
+type MockStateHistoryRepository struct {
+	stateHistories   []model.StateHistory
+	shouldFailGet    bool
+	shouldFailInsert bool
+}
+
+func NewMockStateHistoryRepository() *MockStateHistoryRepository {
+	return &MockStateHistoryRepository{
+		stateHistories: make([]model.StateHistory, 0),
+	}
+}
+
+// GetAll mocks the GetAll method
+func (m *MockStateHistoryRepository) GetAll(ctx context.Context, filter *model.StateHistoryFilter) (*[]model.StateHistory, error) {
+	if m.shouldFailGet {
+		return nil, errors.New("failed to get state history")
+	}
+
+	var filtered []model.StateHistory
+	for _, sh := range m.stateHistories {
+		if m.matchesFilter(sh, filter) {
+			filtered = append(filtered, sh)
+		}
+	}
+
+	return &filtered, nil
+}
+
+// Insert mocks the Insert method
+func (m *MockStateHistoryRepository) Insert(ctx context.Context, stateHistory *model.StateHistory) error {
+	if m.shouldFailInsert {
+		return errors.New("failed to insert state history")
+	}
+
+	// Simulate BeforeCreate hook
+	if stateHistory.ID == uuid.Nil {
+		stateHistory.ID = uuid.New()
+	}
+	if stateHistory.SessionID == uuid.Nil {
+		stateHistory.SessionID = uuid.New()
+	}
+
+	m.stateHistories = append(m.stateHistories, *stateHistory)
+	return nil
+}
+
+// GetLastSessionID mocks the GetLastSessionID method
+func (m *MockStateHistoryRepository) GetLastSessionID(ctx context.Context, serverID uuid.UUID) (uuid.UUID, error) {
+	for i := len(m.stateHistories) - 1; i >= 0; i-- {
+		if m.stateHistories[i].ServerID == serverID {
+			return m.stateHistories[i].SessionID, nil
+		}
+	}
+	return uuid.Nil, nil
+}
+
+// Helper methods for filtering
+func (m *MockStateHistoryRepository) matchesFilter(sh model.StateHistory, filter *model.StateHistoryFilter) bool {
+	if filter == nil {
+		return true
+	}
+
+	if filter.ServerID != "" {
+		serverUUID, err := uuid.Parse(filter.ServerID)
+		if err != nil || sh.ServerID != serverUUID {
+			return false
+		}
+	}
+
+	if filter.Session != "" && sh.Session != filter.Session {
+		return false
+	}
+
+	if filter.MinPlayers != nil && sh.PlayerCount < *filter.MinPlayers {
+		return false
+	}
+
+	if filter.MaxPlayers != nil && sh.PlayerCount > *filter.MaxPlayers {
+		return false
+	}
+
+	return true
+}
+
+// Helper methods for testing configuration
+func (m *MockStateHistoryRepository) SetShouldFailGet(shouldFail bool) {
+	m.shouldFailGet = shouldFail
+}
+
+func (m *MockStateHistoryRepository) SetShouldFailInsert(shouldFail bool) {
+	m.shouldFailInsert = shouldFail
+}
+
+// AddStateHistory adds a state history entry to the mock repository
+func (m *MockStateHistoryRepository) AddStateHistory(stateHistory model.StateHistory) {
+	if stateHistory.ID == uuid.Nil {
+		stateHistory.ID = uuid.New()
+	}
+	if stateHistory.SessionID == uuid.Nil {
+		stateHistory.SessionID = uuid.New()
+	}
+	m.stateHistories = append(m.stateHistories, stateHistory)
+}
+
+// GetCount returns the number of state history entries
+func (m *MockStateHistoryRepository) GetCount() int {
+	return len(m.stateHistories)
+}
+
+// Clear removes all state history entries
+func (m *MockStateHistoryRepository) Clear() {
+	m.stateHistories = make([]model.StateHistory, 0)
+}
+
+// GetSummaryStats calculates peak players, total sessions, and average players for mock data
+func (m *MockStateHistoryRepository) GetSummaryStats(ctx context.Context, filter *model.StateHistoryFilter) (model.StateHistoryStats, error) {
+	var stats model.StateHistoryStats
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	if len(filteredEntries) == 0 {
+		return stats, nil
+	}
+
+	// Calculate statistics
+	sessionMap := make(map[string]bool)
+	totalPlayers := 0
+
+	for _, entry := range filteredEntries {
+		if entry.PlayerCount > stats.PeakPlayers {
+			stats.PeakPlayers = entry.PlayerCount
+		}
+		totalPlayers += entry.PlayerCount
+		sessionMap[entry.SessionID.String()] = true
+	}
+
+	stats.TotalSessions = len(sessionMap)
+	if len(filteredEntries) > 0 {
+		stats.AveragePlayers = float64(totalPlayers) / float64(len(filteredEntries))
+	}
+
+	return stats, nil
+}
+
+// GetTotalPlaytime calculates total playtime in minutes for mock data
+func (m *MockStateHistoryRepository) GetTotalPlaytime(ctx context.Context, filter *model.StateHistoryFilter) (int, error) {
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	if len(filteredEntries) == 0 {
+		return 0, nil
+	}
+
+	// Group by session and calculate durations
+	sessionMap := make(map[string][]model.StateHistory)
+	for _, entry := range filteredEntries {
+		sessionID := entry.SessionID.String()
+		sessionMap[sessionID] = append(sessionMap[sessionID], entry)
+	}
+
+	totalMinutes := 0
+	for _, sessionEntries := range sessionMap {
+		if len(sessionEntries) > 1 {
+			// Sort by date (simple approach for mock)
+			minTime := sessionEntries[0].DateCreated
+			maxTime := sessionEntries[0].DateCreated
+			hasPlayers := false
+
+			for _, entry := range sessionEntries {
+				if entry.DateCreated.Before(minTime) {
+					minTime = entry.DateCreated
+				}
+				if entry.DateCreated.After(maxTime) {
+					maxTime = entry.DateCreated
+				}
+				if entry.PlayerCount > 0 {
+					hasPlayers = true
+				}
+			}
+
+			if hasPlayers {
+				duration := maxTime.Sub(minTime)
+				totalMinutes += int(duration.Minutes())
+			}
+		}
+	}
+
+	return totalMinutes, nil
+}
+
+// GetPlayerCountOverTime returns downsampled player count data for mock
+func (m *MockStateHistoryRepository) GetPlayerCountOverTime(ctx context.Context, filter *model.StateHistoryFilter) ([]model.PlayerCountPoint, error) {
+	var points []model.PlayerCountPoint
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	// Group by hour (simple mock implementation)
+	hourMap := make(map[string][]int)
+	for _, entry := range filteredEntries {
+		hourKey := entry.DateCreated.Format("2006-01-02 15")
+		hourMap[hourKey] = append(hourMap[hourKey], entry.PlayerCount)
+	}
+
+	// Calculate averages per hour
+	for hourKey, counts := range hourMap {
+		total := 0
+		for _, count := range counts {
+			total += count
+		}
+		avg := total / len(counts)
+
+		points = append(points, model.PlayerCountPoint{
+			Timestamp: hourKey,
+			Count:     float64(avg),
+		})
+	}
+
+	return points, nil
+}
+
+// GetSessionTypes counts sessions by type for mock
+func (m *MockStateHistoryRepository) GetSessionTypes(ctx context.Context, filter *model.StateHistoryFilter) ([]model.SessionCount, error) {
+	var sessionTypes []model.SessionCount
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	// Group by session type
+	sessionMap := make(map[string]map[string]bool) // session -> sessionID -> bool
+	for _, entry := range filteredEntries {
+		if sessionMap[entry.Session] == nil {
+			sessionMap[entry.Session] = make(map[string]bool)
+		}
+		sessionMap[entry.Session][entry.SessionID.String()] = true
+	}
+
+	// Count unique sessions per type
+	for sessionType, sessions := range sessionMap {
+		sessionTypes = append(sessionTypes, model.SessionCount{
+			Name:  sessionType,
+			Count: len(sessions),
+		})
+	}
+
+	return sessionTypes, nil
+}
+
+// GetDailyActivity counts sessions per day for mock
+func (m *MockStateHistoryRepository) GetDailyActivity(ctx context.Context, filter *model.StateHistoryFilter) ([]model.DailyActivity, error) {
+	var dailyActivity []model.DailyActivity
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	// Group by day
+	dayMap := make(map[string]map[string]bool) // date -> sessionID -> bool
+	for _, entry := range filteredEntries {
+		dateKey := entry.DateCreated.Format("2006-01-02")
+		if dayMap[dateKey] == nil {
+			dayMap[dateKey] = make(map[string]bool)
+		}
+		dayMap[dateKey][entry.SessionID.String()] = true
+	}
+
+	// Count unique sessions per day
+	for date, sessions := range dayMap {
+		dailyActivity = append(dailyActivity, model.DailyActivity{
+			Date:          date,
+			SessionsCount: len(sessions),
+		})
+	}
+
+	return dailyActivity, nil
+}
+
+// GetRecentSessions retrieves recent sessions for mock
+func (m *MockStateHistoryRepository) GetRecentSessions(ctx context.Context, filter *model.StateHistoryFilter) ([]model.RecentSession, error) {
+	var recentSessions []model.RecentSession
+	var filteredEntries []model.StateHistory
+
+	// Filter entries
+	for _, entry := range m.stateHistories {
+		if m.matchesFilter(entry, filter) {
+			filteredEntries = append(filteredEntries, entry)
+		}
+	}
+
+	// Group by session
+	sessionMap := make(map[string][]model.StateHistory)
+	for _, entry := range filteredEntries {
+		sessionID := entry.SessionID.String()
+		sessionMap[sessionID] = append(sessionMap[sessionID], entry)
+	}
+
+	// Create recent sessions (limit to 10)
+	count := 0
+	for _, entries := range sessionMap {
+		if count >= 10 {
+			break
+		}
+
+		if len(entries) > 0 {
+			// Find min/max dates and max players
+			minDate := entries[0].DateCreated
+			maxDate := entries[0].DateCreated
+			maxPlayers := 0
+
+			for _, entry := range entries {
+				if entry.DateCreated.Before(minDate) {
+					minDate = entry.DateCreated
+				}
+				if entry.DateCreated.After(maxDate) {
+					maxDate = entry.DateCreated
+				}
+				if entry.PlayerCount > maxPlayers {
+					maxPlayers = entry.PlayerCount
+				}
+			}
+
+			// Only include sessions with players
+			if maxPlayers > 0 {
+				duration := int(maxDate.Sub(minDate).Minutes())
+				recentSessions = append(recentSessions, model.RecentSession{
+					ID:       uint(count + 1),
+					Date:     minDate.Format("2006-01-02 15:04:05"),
+					Type:     entries[0].Session,
+					Track:    entries[0].Track,
+					Players:  maxPlayers,
+					Duration: duration,
+				})
+				count++
+			}
+		}
+	}
+
+	return recentSessions, nil
+}