MusicServer/internal/backend/music_test.go

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)
		}
	}
}