358 lines
12 KiB
Go
358 lines
12 KiB
Go
package models
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestAlbum_DeJSON(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`{
|
|
"id": "123",
|
|
"title": "Test Album",
|
|
"cover_uri": "https://example.com/cover.jpg",
|
|
"genre": "rock",
|
|
"year": 2023,
|
|
"track_count": 10,
|
|
"available": true,
|
|
"release_date": "2023-01-15",
|
|
"description": "Test album description",
|
|
"region": "RU",
|
|
"available_for_premium_users": true,
|
|
"available_for_premium_users_only": false,
|
|
"content_warning": "explicit",
|
|
"label": "Test Label",
|
|
"catalog_number": "CAT-123",
|
|
"options": ["option1", "option2"],
|
|
"artists": [{"id": "1", "name": "Artist 1", "cover_uri": "https://example.com/artist.jpg"}],
|
|
"labels": [{"id": "label1", "name": "Label 1"}],
|
|
"volumes": [[{"id": "t1", "title": "Track 1", "duration_ms": 180000}]],
|
|
"meta": {"availability": {"available_for_premium_users": true, "territories": ["RU", "US"]}},
|
|
"best": {"tracks": [{"id": "bt1", "title": "Best Track", "duration_ms": 200000}]},
|
|
"track_positions": [{"revision": 1, "timestamp": "2023-01-01T00:00:00Z", "position": 1, "from_cache": false}],
|
|
"similar_albums": [{"id": "sim1", "title": "Similar Album", "cover_uri": "https://example.com/sim.jpg", "year": 2022}],
|
|
"trailer": {"preview_uri": "https://example.com/preview.mp3", "track_id": "t1", "album_id": "123", "duration": 30}
|
|
}`)
|
|
|
|
album := &Album{BaseModel: *NewBaseModel(client)}
|
|
result, err := album.DeJSON(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeJSON failed: %v", err)
|
|
}
|
|
|
|
resultAlbum := result.(*Album)
|
|
if resultAlbum.ID != "123" {
|
|
t.Errorf("Expected ID '123', got '%s'", resultAlbum.ID)
|
|
}
|
|
if resultAlbum.Title != "Test Album" {
|
|
t.Errorf("Expected Title 'Test Album', got '%s'", resultAlbum.Title)
|
|
}
|
|
if resultAlbum.CoverURI != "https://example.com/cover.jpg" {
|
|
t.Errorf("Expected CoverURI 'https://example.com/cover.jpg', got '%s'", resultAlbum.CoverURI)
|
|
}
|
|
if resultAlbum.Genre != "rock" {
|
|
t.Errorf("Expected Genre 'rock', got '%s'", resultAlbum.Genre)
|
|
}
|
|
if resultAlbum.Year != 2023 {
|
|
t.Errorf("Expected Year 2023, got %d", resultAlbum.Year)
|
|
}
|
|
if resultAlbum.TrackCount != 10 {
|
|
t.Errorf("Expected TrackCount 10, got %d", resultAlbum.TrackCount)
|
|
}
|
|
if !resultAlbum.Available {
|
|
t.Errorf("Expected Available true, got false")
|
|
}
|
|
if resultAlbum.ReleaseDate != "2023-01-15" {
|
|
t.Errorf("Expected ReleaseDate '2023-01-15', got '%s'", resultAlbum.ReleaseDate)
|
|
}
|
|
if resultAlbum.Description != "Test album description" {
|
|
t.Errorf("Expected Description 'Test album description', got '%s'", resultAlbum.Description)
|
|
}
|
|
if resultAlbum.Region != "RU" {
|
|
t.Errorf("Expected Region 'RU', got '%s'", resultAlbum.Region)
|
|
}
|
|
if !resultAlbum.AvailableForPremiumUsers {
|
|
t.Errorf("Expected AvailableForPremiumUsers true, got false")
|
|
}
|
|
if resultAlbum.AvailableForPremiumUsersOnly {
|
|
t.Errorf("Expected AvailableForPremiumUsersOnly false, got true")
|
|
}
|
|
if resultAlbum.ContentWarning != "explicit" {
|
|
t.Errorf("Expected ContentWarning 'explicit', got '%s'", resultAlbum.ContentWarning)
|
|
}
|
|
if resultAlbum.Label != "Test Label" {
|
|
t.Errorf("Expected Label 'Test Label', got '%s'", resultAlbum.Label)
|
|
}
|
|
if resultAlbum.CatalogNumber != "CAT-123" {
|
|
t.Errorf("Expected CatalogNumber 'CAT-123', got '%s'", resultAlbum.CatalogNumber)
|
|
}
|
|
if len(resultAlbum.Options) != 2 {
|
|
t.Errorf("Expected 2 options, got %d", len(resultAlbum.Options))
|
|
}
|
|
|
|
// Test nested artists
|
|
if len(resultAlbum.Artists) != 1 {
|
|
t.Errorf("Expected 1 artist, got %d", len(resultAlbum.Artists))
|
|
}
|
|
if resultAlbum.Artists[0].Name != "Artist 1" {
|
|
t.Errorf("Expected artist name 'Artist 1', got '%s'", resultAlbum.Artists[0].Name)
|
|
}
|
|
|
|
// Test nested labels
|
|
if len(resultAlbum.Labels) != 1 {
|
|
t.Errorf("Expected 1 label, got %d", len(resultAlbum.Labels))
|
|
}
|
|
if resultAlbum.Labels[0].Name != "Label 1" {
|
|
t.Errorf("Expected label name 'Label 1', got '%s'", resultAlbum.Labels[0].Name)
|
|
}
|
|
|
|
// Test volumes
|
|
if len(resultAlbum.Volumes) != 1 {
|
|
t.Errorf("Expected 1 volume, got %d", len(resultAlbum.Volumes))
|
|
}
|
|
if len(resultAlbum.Volumes[0]) != 1 {
|
|
t.Errorf("Expected 1 track in volume, got %d", len(resultAlbum.Volumes[0]))
|
|
}
|
|
if resultAlbum.Volumes[0][0].Title != "Track 1" {
|
|
t.Errorf("Expected track title 'Track 1', got '%s'", resultAlbum.Volumes[0][0].Title)
|
|
}
|
|
|
|
// Test meta
|
|
if resultAlbum.Meta == nil {
|
|
t.Fatal("Expected Meta to be non-nil")
|
|
}
|
|
if resultAlbum.Meta.Availability == nil {
|
|
t.Fatal("Expected Availability to be non-nil")
|
|
}
|
|
if !resultAlbum.Meta.Availability.AvailableForPremiumUsers {
|
|
t.Errorf("Expected AvailableForPremiumUsers true in meta")
|
|
}
|
|
if len(resultAlbum.Meta.Availability.Territories) != 2 {
|
|
t.Errorf("Expected 2 territories, got %d", len(resultAlbum.Meta.Availability.Territories))
|
|
}
|
|
|
|
// Test best
|
|
if resultAlbum.Best == nil {
|
|
t.Fatal("Expected Best to be non-nil")
|
|
}
|
|
if len(resultAlbum.Best.Tracks) != 1 {
|
|
t.Errorf("Expected 1 best track, got %d", len(resultAlbum.Best.Tracks))
|
|
}
|
|
if resultAlbum.Best.Tracks[0].Title != "Best Track" {
|
|
t.Errorf("Expected best track title 'Best Track', got '%s'", resultAlbum.Best.Tracks[0].Title)
|
|
}
|
|
|
|
// Test track positions
|
|
if len(resultAlbum.TrackPositions) != 1 {
|
|
t.Errorf("Expected 1 track position, got %d", len(resultAlbum.TrackPositions))
|
|
}
|
|
if resultAlbum.TrackPositions[0].Position != 1 {
|
|
t.Errorf("Expected position 1, got %d", resultAlbum.TrackPositions[0].Position)
|
|
}
|
|
if resultAlbum.TrackPositions[0].Revision != 1 {
|
|
t.Errorf("Expected revision 1, got %d", resultAlbum.TrackPositions[0].Revision)
|
|
}
|
|
|
|
// Test similar albums
|
|
if len(resultAlbum.SimilarAlbums) != 1 {
|
|
t.Errorf("Expected 1 similar album, got %d", len(resultAlbum.SimilarAlbums))
|
|
}
|
|
if resultAlbum.SimilarAlbums[0].Title != "Similar Album" {
|
|
t.Errorf("Expected similar album title 'Similar Album', got '%s'", resultAlbum.SimilarAlbums[0].Title)
|
|
}
|
|
|
|
// Test trailer
|
|
if resultAlbum.Trailer == nil {
|
|
t.Fatal("Expected Trailer to be non-nil")
|
|
}
|
|
if resultAlbum.Trailer.PreviewURI != "https://example.com/preview.mp3" {
|
|
t.Errorf("Expected PreviewURI 'https://example.com/preview.mp3', got '%s'", resultAlbum.Trailer.PreviewURI)
|
|
}
|
|
if resultAlbum.Trailer.TrackID != "t1" {
|
|
t.Errorf("Expected TrackID 't1', got '%s'", resultAlbum.Trailer.TrackID)
|
|
}
|
|
if resultAlbum.Trailer.AlbumID != "123" {
|
|
t.Errorf("Expected AlbumID '123', got '%s'", resultAlbum.Trailer.AlbumID)
|
|
}
|
|
if resultAlbum.Trailer.Duration != 30 {
|
|
t.Errorf("Expected Duration 30, got %d", resultAlbum.Trailer.Duration)
|
|
}
|
|
}
|
|
|
|
func TestAlbum_DeJSON_Minimal(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`{
|
|
"id": "minimal",
|
|
"title": "Minimal Album"
|
|
}`)
|
|
|
|
album := &Album{BaseModel: *NewBaseModel(client)}
|
|
result, err := album.DeJSON(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeJSON failed: %v", err)
|
|
}
|
|
|
|
resultAlbum := result.(*Album)
|
|
if resultAlbum.ID != "minimal" {
|
|
t.Errorf("Expected ID 'minimal', got '%s'", resultAlbum.ID)
|
|
}
|
|
if resultAlbum.Title != "Minimal Album" {
|
|
t.Errorf("Expected Title 'Minimal Album', got '%s'", resultAlbum.Title)
|
|
}
|
|
// Other fields should be zero values
|
|
if resultAlbum.Year != 0 {
|
|
t.Errorf("Expected Year 0, got %d", resultAlbum.Year)
|
|
}
|
|
if resultAlbum.Available {
|
|
t.Errorf("Expected Available false, got true")
|
|
}
|
|
}
|
|
|
|
func TestAlbum_DeList(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`[
|
|
{"id": "1", "title": "Album 1", "year": 2022, "track_count": 5, "available": true},
|
|
{"id": "2", "title": "Album 2", "year": 2023, "track_count": 8, "available": true},
|
|
{"id": "3", "title": "Album 3", "year": 2021, "track_count": 12, "available": false}
|
|
]`)
|
|
|
|
album := &Album{BaseModel: *NewBaseModel(client)}
|
|
result, err := album.DeList(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeList failed: %v", err)
|
|
}
|
|
|
|
if len(result) != 3 {
|
|
t.Errorf("Expected 3 albums, got %d", len(result))
|
|
}
|
|
|
|
albums := make([]*Album, len(result))
|
|
for i, a := range result {
|
|
albums[i] = a.(*Album)
|
|
}
|
|
|
|
if albums[0].ID != "1" || albums[0].Title != "Album 1" || albums[0].Year != 2022 {
|
|
t.Errorf("Album 1 mismatch: %+v", albums[0])
|
|
}
|
|
if albums[1].ID != "2" || albums[1].Title != "Album 2" || albums[1].Year != 2023 {
|
|
t.Errorf("Album 2 mismatch: %+v", albums[1])
|
|
}
|
|
if albums[2].ID != "3" || albums[2].Title != "Album 3" || albums[2].Year != 2021 {
|
|
t.Errorf("Album 3 mismatch: %+v", albums[2])
|
|
}
|
|
}
|
|
|
|
func TestAlbum_DeList_Empty(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`[]`)
|
|
|
|
album := &Album{BaseModel: *NewBaseModel(client)}
|
|
result, err := album.DeList(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeList failed: %v", err)
|
|
}
|
|
|
|
if len(result) != 0 {
|
|
t.Errorf("Expected 0 albums, got %d", len(result))
|
|
}
|
|
}
|
|
|
|
func TestAlbumMeta_DeJSON(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`{
|
|
"availability": {"available_for_premium_users": true, "territories": ["RU", "US", "EU"]},
|
|
"upsell": {"type": "premium", "description": "Upgrade to premium for full access"}
|
|
}`)
|
|
|
|
meta := &AlbumMeta{BaseModel: *NewBaseModel(client)}
|
|
result, err := meta.DeJSON(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeJSON failed: %v", err)
|
|
}
|
|
|
|
resultMeta := result.(*AlbumMeta)
|
|
if resultMeta.Availability == nil {
|
|
t.Fatal("Expected Availability to be non-nil")
|
|
}
|
|
if !resultMeta.Availability.AvailableForPremiumUsers {
|
|
t.Errorf("Expected AvailableForPremiumUsers true")
|
|
}
|
|
if len(resultMeta.Availability.Territories) != 3 {
|
|
t.Errorf("Expected 3 territories, got %d", len(resultMeta.Availability.Territories))
|
|
}
|
|
if resultMeta.Upsell == nil {
|
|
t.Fatal("Expected Upsell to be non-nil")
|
|
}
|
|
if resultMeta.Upsell.Type != "premium" {
|
|
t.Errorf("Expected Upsell Type 'premium', got '%s'", resultMeta.Upsell.Type)
|
|
}
|
|
if resultMeta.Upsell.Description != "Upgrade to premium for full access" {
|
|
t.Errorf("Expected Upsell Description 'Upgrade to premium for full access', got '%s'", resultMeta.Upsell.Description)
|
|
}
|
|
}
|
|
|
|
func TestAlbumMeta_DeList(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`[
|
|
{"availability": {"available_for_premium_users": true}},
|
|
{"availability": {"available_for_premium_users": false}}
|
|
]`)
|
|
|
|
meta := &AlbumMeta{BaseModel: *NewBaseModel(client)}
|
|
result, err := meta.DeList(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeList failed: %v", err)
|
|
}
|
|
|
|
if len(result) != 2 {
|
|
t.Errorf("Expected 2 meta objects, got %d", len(result))
|
|
}
|
|
}
|
|
|
|
func TestTrailerInfo_DeJSON(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`{
|
|
"preview_uri": "https://example.com/preview.mp3",
|
|
"track_id": "track123",
|
|
"album_id": "album456",
|
|
"duration": 45
|
|
}`)
|
|
|
|
trailer := &TrailerInfo{BaseModel: *NewBaseModel(client)}
|
|
result, err := trailer.DeJSON(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeJSON failed: %v", err)
|
|
}
|
|
|
|
resultTrailer := result.(*TrailerInfo)
|
|
if resultTrailer.PreviewURI != "https://example.com/preview.mp3" {
|
|
t.Errorf("Expected PreviewURI 'https://example.com/preview.mp3', got '%s'", resultTrailer.PreviewURI)
|
|
}
|
|
if resultTrailer.TrackID != "track123" {
|
|
t.Errorf("Expected TrackID 'track123', got '%s'", resultTrailer.TrackID)
|
|
}
|
|
if resultTrailer.AlbumID != "album456" {
|
|
t.Errorf("Expected AlbumID 'album456', got '%s'", resultTrailer.AlbumID)
|
|
}
|
|
if resultTrailer.Duration != 45 {
|
|
t.Errorf("Expected Duration 45, got %d", resultTrailer.Duration)
|
|
}
|
|
}
|
|
|
|
func TestTrailerInfo_DeList(t *testing.T) {
|
|
client := newMockClient()
|
|
data := []byte(`[
|
|
{"preview_uri": "https://example.com/preview1.mp3", "track_id": "t1", "album_id": "a1", "duration": 30},
|
|
{"preview_uri": "https://example.com/preview2.mp3", "track_id": "t2", "album_id": "a2", "duration": 45}
|
|
]`)
|
|
|
|
trailer := &TrailerInfo{BaseModel: *NewBaseModel(client)}
|
|
result, err := trailer.DeList(data, client)
|
|
if err != nil {
|
|
t.Fatalf("DeList failed: %v", err)
|
|
}
|
|
|
|
if len(result) != 2 {
|
|
t.Errorf("Expected 2 trailers, got %d", len(result))
|
|
}
|
|
}
|