286be8ba1d
- docs: SCOPE_CONTROL, CONTRIBUTING, README, .github templates - frontend: DeveloperDashboardView, Player components, MSW handlers, auth, reactQuerySync - backend: playback_analytics, playlist_service, testutils, integration README Excluded (artifacts): .auth, playwright-report, test-results, storybook_audit_detailed.json
272 lines
7.3 KiB
Go
272 lines
7.3 KiB
Go
package testutils
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"veza-backend-api/internal/models"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestCreateTestUser(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, user)
|
|
|
|
// Username and email are made unique with UUID suffix, so check they contain the original values
|
|
assert.Contains(t, user.Username, "testuser")
|
|
assert.Contains(t, user.Email, "test")
|
|
assert.Contains(t, user.Email, "@example.com")
|
|
assert.True(t, user.IsActive)
|
|
assert.True(t, user.IsVerified)
|
|
assert.False(t, user.IsAdmin)
|
|
assert.NotEqual(t, uuid.Nil, user.ID)
|
|
}
|
|
|
|
func TestCreateTestUserWithCustomData(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
username := "customuser"
|
|
email := "custom@example.com"
|
|
|
|
user, err := CreateTestUserWithCustomData(db, username, email)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, user)
|
|
|
|
// Username and email are made unique with UUID suffix, so check they contain the original values
|
|
assert.Contains(t, user.Username, username)
|
|
// Email is made unique by adding UUID to local part, so check it contains the original local part and domain
|
|
assert.Contains(t, user.Email, "custom")
|
|
assert.Contains(t, user.Email, "@example.com")
|
|
}
|
|
|
|
func TestCreateTestAdmin(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
admin, err := CreateTestAdmin(db)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, admin)
|
|
|
|
// Username and email are made unique with UUID suffix, so check they contain the original values
|
|
assert.Contains(t, admin.Username, "admin")
|
|
assert.Contains(t, admin.Email, "admin")
|
|
assert.Contains(t, admin.Email, "@example.com")
|
|
assert.True(t, admin.IsAdmin)
|
|
assert.Equal(t, "admin", admin.Role)
|
|
}
|
|
|
|
func TestCreateTestTrack(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
track, err := CreateTestTrack(db, user.ID)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, track)
|
|
|
|
assert.Equal(t, "Test Track", track.Title)
|
|
assert.Equal(t, "Test Artist", track.Artist)
|
|
assert.Equal(t, 180, track.Duration)
|
|
assert.Equal(t, user.ID, track.UserID) // Changed CreatorID to UserID
|
|
assert.NotEqual(t, uuid.Nil, track.ID)
|
|
}
|
|
|
|
func TestCreateTestTrackWithCustomData(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
title := "Custom Track"
|
|
artist := "Custom Artist"
|
|
|
|
track, err := CreateTestTrackWithCustomData(db, user.ID, title, artist)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, track)
|
|
|
|
assert.Equal(t, title, track.Title)
|
|
assert.Equal(t, artist, track.Artist)
|
|
}
|
|
|
|
func TestCreateTestPlaylist(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
playlist, err := CreateTestPlaylist(db, user.ID)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, playlist)
|
|
|
|
assert.Equal(t, "Test Playlist", playlist.Title) // Changed Name to Title
|
|
assert.Equal(t, user.ID, playlist.UserID)
|
|
assert.NotEqual(t, uuid.Nil, playlist.ID)
|
|
}
|
|
|
|
func TestCreateTestRoom(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
room, err := CreateTestRoom(db, user.ID) // CreatedBy is UUID now
|
|
require.NoError(t, err)
|
|
require.NotNil(t, room)
|
|
|
|
assert.Equal(t, "Test Room", room.Name)
|
|
assert.Equal(t, user.ID, room.CreatedBy)
|
|
assert.False(t, room.IsPrivate)
|
|
assert.Equal(t, "public", room.Type)
|
|
}
|
|
|
|
func TestCreateTestMessage(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
room, err := CreateTestRoom(db, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
content := "Test message content"
|
|
message, err := CreateTestMessage(db, room.ID, user.ID, content) // room.ID is UUID now
|
|
require.NoError(t, err)
|
|
require.NotNil(t, message)
|
|
|
|
assert.Equal(t, content, message.Content)
|
|
assert.Equal(t, room.ID, message.RoomID)
|
|
assert.Equal(t, user.ID, message.UserID)
|
|
assert.Equal(t, "text", message.Type)
|
|
assert.False(t, message.IsEdited)
|
|
assert.False(t, message.IsDeleted)
|
|
}
|
|
|
|
func TestCreateTestSession(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
session, err := CreateTestSession(db, user.ID) // User.ID is UUID
|
|
require.NoError(t, err)
|
|
require.NotNil(t, session)
|
|
|
|
assert.Equal(t, user.ID, session.UserID)
|
|
assert.NotEqual(t, uuid.Nil, session.ID) // Session.ID is uuid.UUID
|
|
}
|
|
|
|
func TestCreateMultipleTestUsers(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
count := 5
|
|
users, err := CreateMultipleTestUsers(db, count)
|
|
require.NoError(t, err)
|
|
require.Len(t, users, count)
|
|
|
|
// Vérifier que tous les utilisateurs ont des IDs uniques
|
|
// IDs sont maintenant UUID, donc comparaison avec uuid.Nil
|
|
for _, user := range users {
|
|
assert.NotEqual(t, uuid.Nil, user.ID)
|
|
}
|
|
|
|
// Vérifier que les usernames sont différents
|
|
usernames := make(map[string]bool)
|
|
for _, user := range users {
|
|
assert.False(t, usernames[user.Username], "Duplicate username")
|
|
usernames[user.Username] = true
|
|
}
|
|
}
|
|
|
|
func TestCreateMultipleTestTracks(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
count := 3
|
|
tracks, err := CreateMultipleTestTracks(db, user.ID, count)
|
|
require.NoError(t, err)
|
|
require.Len(t, tracks, count)
|
|
|
|
// Vérifier que tous les tracks ont le même créateur
|
|
for _, track := range tracks {
|
|
assert.Equal(t, user.ID, track.UserID) // Changed CreatorID to UserID
|
|
assert.NotEqual(t, uuid.Nil, track.ID)
|
|
}
|
|
|
|
// Vérifier que les titres sont différents
|
|
titles := make(map[string]bool)
|
|
for _, track := range tracks {
|
|
assert.False(t, titles[track.Title], "Duplicate track title")
|
|
titles[track.Title] = true
|
|
}
|
|
}
|
|
|
|
// Test helper pour vérifier que les fixtures respectent les contraintes
|
|
func TestFixtures_ForeignKeyConstraints(t *testing.T) {
|
|
SkipIfDockerUnavailable(t)
|
|
db := SetupTestDB()
|
|
require.NotNil(t, db)
|
|
defer CleanupTestDB(db)
|
|
|
|
// Créer un utilisateur
|
|
user, err := CreateTestUser(db)
|
|
require.NoError(t, err)
|
|
|
|
// Créer un track avec le bon userID
|
|
track, err := CreateTestTrack(db, user.ID)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, track)
|
|
|
|
// Essayer de créer un track avec un userID inexistant devrait échouer en production
|
|
// mais SQLite en mémoire peut ne pas toujours faire respecter les contraintes
|
|
invalidTrack := &models.Track{
|
|
UserID: uuid.New(), // Changed CreatorID to UserID, use new UUID
|
|
Title: "Invalid Track",
|
|
Duration: 180,
|
|
FilePath: "uploads/invalid.mp3",
|
|
FileSize: 100,
|
|
Format: "mp3",
|
|
}
|
|
err = db.Create(invalidTrack).Error
|
|
// En production, cela devrait échouer, mais en test SQLite, on peut l'ignorer
|
|
_ = err
|
|
}
|