Restructure backend into services and fix security, crash and sync issues

Security
- Serve character images through os.Root so names like ../ can't escape
  the characters folder
- Sync start and /sync/reset are POST only (legacy and /api/v1)
- /api/v1/token/cleanup requires a token, password compared in constant
  time, tokens no longer logged
- Echo's rate limiter replaces the custom one; TRUSTED_PROXIES enables
  X-Forwarded-For for reverse proxies

Crashes and races
- Sync state lives in SyncService with atomics and a mutex instead of
  unsynchronised globals (fixes concurrent map writes during full sync)
- Only one sync can run; /api/v1 sync and music routes are locked during
  sync like the legacy ones
- No log.Fatal outside startup: errors become 4xx/5xx responses
- Search uses an in-order character match instead of unescaped regexes
- Empty queue / no songs return 404 instead of panicking or looping

Behaviour
- Sync result is computed once and stays the same between polls
- Swagger and /openapi serve the embedded spec
- Shutdown stops HTTP before closing the database
- Expired tokens are deleted with a context that outlives the request
- Files are served with Range support and correct content types; audio
  has no write deadline

Performance
- Migration 000006 adds soundtrack.fingerprint (names, sizes, mtimes) so
  unchanged folders are skipped without reading any files
- Songs are reconciled per soundtrack with one query plus needed writes;
  renames keep play counts
- Moved MUSIC_PATH updates soundtrack and song paths
- .id cleanup only runs for changed soundtracks or a full sync
- Classic random uses one SQL query; Gitea release lookups are cached
  with a timeout

Structure
- internal/config reads all environment variables once
- sqlc emits a Querier interface; backend globals become services
  injected into handlers
- One route registration shared by legacy and /api/v1
- Removed dead code (dbHelper.go, unused middleware, duplicate Gitea
  functions, embedded Swagger UI copy) and lib/pq
- templ and swag pinned as go tools
This commit is contained in:
Sansan committed 2026-10-06 15:20:14 +02:00
1 parent 75b6f0c1cf
commit 090e794460
78 files changed
+2919 -6303

No files matched your search

-201
View File
@@ -1,201 +0,0 @@
package backend
import (
"math/rand"
"testing"
"music-server/internal/db/repository"
)
// Test the average calculation logic directly without database access
func TestCalculateAverage(t *testing.T) {
soundtracks := []repository.Soundtrack{
{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
}
var sum int32
for _, data := range soundtracks {
sum += data.TimesPlayed
}
result := sum / int32(len(soundtracks))
expected := int32(20)
if result != expected {
t.Errorf("Average calculation = %v, want %v", result, expected)
}
}
func TestCalculateAverageEmpty(t *testing.T) {
soundtracks := []repository.Soundtrack{}
if len(soundtracks) == 0 {
result := int32(0)
expected := int32(0)
if result != expected {
t.Errorf("Average calculation with empty list = %v, want %v", result, expected)
}
return
}
var sum int32
for _, data := range soundtracks {
sum += data.TimesPlayed
}
result := sum / int32(len(soundtracks))
expected := int32(0)
if result != expected {
t.Errorf("Average calculation with empty list = %v, want %v", result, expected)
}
}
func TestCalculateAverageSingle(t *testing.T) {
soundtracks := []repository.Soundtrack{
{SoundtrackName: "Soundtrack1", TimesPlayed: 42},
}
var sum int32
for _, data := range soundtracks {
sum += data.TimesPlayed
}
result := sum / int32(len(soundtracks))
expected := int32(42)
if result != expected {
t.Errorf("Average calculation with single soundtrack = %v, want %v", result, expected)
}
}
func TestGetRandomSoundtrack(t *testing.T) {
soundtracks := []repository.Soundtrack{
{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
}
// Set seed for reproducible tests
rand.Seed(42)
result := soundtracks[rand.Intn(len(soundtracks))]
if result.SoundtrackName == "" {
t.Error("random soundtrack selection returned empty soundtrack")
}
found := false
for _, s := range soundtracks {
if s.SoundtrackName == result.SoundtrackName {
found = true
break
}
}
if !found {
t.Errorf("random soundtrack selection returned soundtrack not in list: %v", result.SoundtrackName)
}
}
func TestFindSoundtrackByID(t *testing.T) {
soundtracks := []repository.Soundtrack{
{ID: 1, SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{ID: 3, SoundtrackName: "Soundtrack3", TimesPlayed: 30},
}
tests := []struct {
name string
soundtracks []repository.Soundtrack
soundtrackID int32
expected repository.Soundtrack
}{
{
name: "existing soundtrack",
soundtracks: soundtracks,
soundtrackID: 2,
expected: repository.Soundtrack{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
},
{
name: "non-existing soundtrack",
soundtracks: soundtracks,
soundtrackID: 99,
expected: repository.Soundtrack{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var result repository.Soundtrack
for _, s := range tt.soundtracks {
if s.ID == tt.soundtrackID {
result = s
break
}
}
if result.ID != tt.expected.ID || result.SoundtrackName != tt.expected.SoundtrackName {
t.Errorf("findSoundtrackByID() = %v, want %v", result, tt.expected)
}
})
}
}
func TestExtractSoundtrackNames(t *testing.T) {
soundtracks := []repository.Soundtrack{
{SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Soundtrack3", TimesPlayed: 30},
}
var result []string
for _, s := range soundtracks {
result = append(result, s.SoundtrackName)
}
expected := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
if len(result) != len(expected) {
t.Errorf("extractSoundtrackNames() length = %d, want %d", len(result), len(expected))
return
}
for i, v := range result {
if v != expected[i] {
t.Errorf("extractSoundtrackNames()[%d] = %v, want %v", i, v, expected[i])
}
}
}
func TestShuffleSoundtrackNames(t *testing.T) {
soundtracks := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
// Test that shuffle doesn't lose any elements
// We can't test the order since it's random, but we can test length and contents
original := make([]string, len(soundtracks))
copy(original, soundtracks)
// Simple shuffle implementation for testing
for i := range soundtracks {
j := i // In real code this would be random
soundtracks[i], soundtracks[j] = soundtracks[j], soundtracks[i]
}
if len(soundtracks) != len(original) {
t.Errorf("shuffleSoundtrackNames() changed length from %d to %d", len(original), len(soundtracks))
return
}
// Check all original elements are still present
for _, orig := range original {
found := false
for _, s := range soundtracks {
if s == orig {
found = true
break
}
}
if !found {
t.Errorf("shuffleSoundtrackNames() lost element: %v", orig)
}
}
}