veza/veza-backend-api/internal/models/track_play_test.go

package models

import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func TestTrackPlay(t *testing.T) {
	// Setup in-memory database
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	assert.NoError(t, err)

	// Enable foreign keys for SQLite
	db.Exec("PRAGMA foreign_keys = ON")

	// Auto migrate
	err = db.AutoMigrate(&User{}, &Track{}, &TrackPlay{})
	assert.NoError(t, err)

	t.Run("Create TrackPlay with user", func(t *testing.T) {
		// Create user
		user := &User{
			Username:     "testuser",
			Email:        "test@example.com",
			PasswordHash: "hash",
			Slug:         "testuser",
			IsActive:     true,
		}
		err := db.Create(user).Error
		assert.NoError(t, err)

		// Create track
		track := &Track{
			UserID:   user.ID,
			Title:    "Test Track",
			FilePath: "/test/track.mp3",
			FileSize: 5 * 1024 * 1024,
			Format:   "MP3",
			Duration: 180,
			IsPublic: true,
			Status:   TrackStatusCompleted,
		}
		err = db.Create(track).Error
		assert.NoError(t, err)

		// Create track play
		userID := user.ID
		trackPlay := &TrackPlay{
			TrackID:   track.ID,
			UserID:    &userID,
			Duration:  120,
			PlayedAt:  time.Now(),
			Device:    "Chrome",
			IPAddress: "192.168.1.1",
		}
		err = db.Create(trackPlay).Error
		assert.NoError(t, err)
		assert.NotZero(t, trackPlay.ID)
		assert.Equal(t, track.ID, trackPlay.TrackID)
		assert.NotNil(t, trackPlay.UserID)
		assert.Equal(t, user.ID, *trackPlay.UserID)
		assert.Equal(t, 120, trackPlay.Duration)
		assert.Equal(t, "Chrome", trackPlay.Device)
		assert.Equal(t, "192.168.1.1", trackPlay.IPAddress)
	})

	t.Run("Create TrackPlay without user (anonymous)", func(t *testing.T) {
		// Create user
		user := &User{
			Username:     "testuser2",
			Email:        "test2@example.com",
			PasswordHash: "hash",
			Slug:         "testuser2",
			IsActive:     true,
		}
		err := db.Create(user).Error
		assert.NoError(t, err)

		// Create track
		track := &Track{
			UserID:   user.ID,
			Title:    "Test Track 2",
			FilePath: "/test/track2.mp3",
			FileSize: 5 * 1024 * 1024,
			Format:   "MP3",
			Duration: 180,
			IsPublic: true,
			Status:   TrackStatusCompleted,
		}
		err = db.Create(track).Error
		assert.NoError(t, err)

		// Create anonymous track play
		trackPlay := &TrackPlay{
			TrackID:   track.ID,
			UserID:    nil,
			Duration:  60,
			PlayedAt:  time.Now(),
			Device:    "Firefox",
			IPAddress: "10.0.0.1",
		}
		err = db.Create(trackPlay).Error
		assert.NoError(t, err)
		assert.NotZero(t, trackPlay.ID)
		assert.Equal(t, track.ID, trackPlay.TrackID)
		assert.Nil(t, trackPlay.UserID)
		assert.Equal(t, 60, trackPlay.Duration)
	})

	t.Run("TrackPlay cascade delete on track", func(t *testing.T) {
		// Create user and track
		user := &User{
			Username:     "testuser3",
			Email:        "test3@example.com",
			PasswordHash: "hash",
			Slug:         "testuser3",
			IsActive:     true,
		}
		err := db.Create(user).Error
		assert.NoError(t, err)

		track := &Track{
			UserID:   user.ID,
			Title:    "Test Track 3",
			FilePath: "/test/track3.mp3",
			FileSize: 5 * 1024 * 1024,
			Format:   "MP3",
			Duration: 180,
			IsPublic: true,
			Status:   TrackStatusCompleted,
		}
		err = db.Create(track).Error
		assert.NoError(t, err)

		// Create track play
		userID := user.ID
		trackPlay := &TrackPlay{
			TrackID:  track.ID,
			UserID:   &userID,
			Duration: 90,
			PlayedAt: time.Now(),
		}
		err = db.Create(trackPlay).Error
		assert.NoError(t, err)

		// Verify track play was created
		var count int64
		db.Model(&TrackPlay{}).Where("id = ?", trackPlay.ID).Count(&count)
		assert.Equal(t, int64(1), count)

		// Note: Cascade delete is tested at database level with PostgreSQL
		// SQLite in-memory has limitations with foreign key constraints
		// The migration SQL file includes ON DELETE CASCADE which will work in production
	})

	t.Run("TrackPlay set null on user delete", func(t *testing.T) {
		// Create user and track
		user := &User{
			Username:     "testuser4",
			Email:        "test4@example.com",
			PasswordHash: "hash",
			Slug:         "testuser4",
			IsActive:     true,
		}
		err := db.Create(user).Error
		assert.NoError(t, err)

		track := &Track{
			UserID:   user.ID,
			Title:    "Test Track 4",
			FilePath: "/test/track4.mp3",
			FileSize: 5 * 1024 * 1024,
			Format:   "MP3",
			Duration: 180,
			IsPublic: true,
			Status:   TrackStatusCompleted,
		}
		err = db.Create(track).Error
		assert.NoError(t, err)

		// Create track play
		userID := user.ID
		trackPlay := &TrackPlay{
			TrackID:  track.ID,
			UserID:   &userID,
			Duration: 100,
			PlayedAt: time.Now(),
		}
		err = db.Create(trackPlay).Error
		assert.NoError(t, err)

		// Verify track play was created with user_id
		var createdPlay TrackPlay
		err = db.First(&createdPlay, trackPlay.ID).Error
		assert.NoError(t, err)
		assert.NotNil(t, createdPlay.UserID)
		assert.Equal(t, user.ID, *createdPlay.UserID)

		// Note: SET NULL on user delete is tested at database level with PostgreSQL
		// SQLite in-memory has limitations with foreign key constraints
		// The migration SQL file includes ON DELETE SET NULL which will work in production
	})

	t.Run("TrackPlay table name", func(t *testing.T) {
		trackPlay := &TrackPlay{}
		assert.Equal(t, "track_plays", trackPlay.TableName())
	})

	t.Run("TrackPlay timestamps", func(t *testing.T) {
		// Create user and track
		user := &User{
			Username:     "testuser5",
			Email:        "test5@example.com",
			PasswordHash: "hash",
			Slug:         "testuser5",
			IsActive:     true,
		}
		err := db.Create(user).Error
		assert.NoError(t, err)

		track := &Track{
			UserID:   user.ID,
			Title:    "Test Track 5",
			FilePath: "/test/track5.mp3",
			FileSize: 5 * 1024 * 1024,
			Format:   "MP3",
			Duration: 180,
			IsPublic: true,
			Status:   TrackStatusCompleted,
		}
		err = db.Create(track).Error
		assert.NoError(t, err)

		// Create track play
		now := time.Now()
		trackPlay := &TrackPlay{
			TrackID:  track.ID,
			Duration: 150,
			PlayedAt: now,
		}
		err = db.Create(trackPlay).Error
		assert.NoError(t, err)
		assert.False(t, trackPlay.CreatedAt.IsZero())
		assert.False(t, trackPlay.UpdatedAt.IsZero())

		// Update track play
		oldUpdatedAt := trackPlay.UpdatedAt
		time.Sleep(10 * time.Millisecond)
		trackPlay.Duration = 200
		err = db.Save(trackPlay).Error
		assert.NoError(t, err)
		assert.True(t, trackPlay.UpdatedAt.After(oldUpdatedAt))
	})
}