HEAVY: finish music service migration, tidy up services, more tests

model/release_test.go

@@ -1,6 +1,7 @@
-package model
+package model_test
 
 import (
+	"arimelody-web/model"
 	"strings"
 	"testing"
 	"time"
@@ -10,7 +11,7 @@ import (
 
 func Test_Release(t *testing.T) {
     t.Run("prints correct description HTML", func(t *testing.T) {
-        release := Release{
+        release := model.Release{
             Description: "this is\na test\n<strong>description!</strong>",
         }
 
@@ -24,7 +25,7 @@ func Test_Release(t *testing.T) {
     })
 
     t.Run("prints correct release date", func(t *testing.T) {
-        release := Release{
+        release := model.Release{
             ReleaseDate: time.Date(2025, time.July, 26, 16, 0, 0, 0, time.UTC),
         }
 
@@ -34,37 +35,37 @@ func Test_Release(t *testing.T) {
 
     t.Run("returns correct artwork", func(t *testing.T) {
         artwork := "testartwork.png"
-        release := Release{ Artwork: artwork }
+        release := model.Release{ Artwork: artwork }
         assert.Equal(t, release.GetArtwork(), artwork)
     })
 
     t.Run("returns placeholder artwork when empty", func(t *testing.T) {
-        release := Release{}
-        assert.Equal(t, release.GetArtwork(), "/img/default-cover-art.png")
+        release := model.Release{}
+        assert.Equal(t, release.GetArtwork(), model.DEFAULT_RELEASE_ARTWORK_URL)
     })
 
     t.Run("singles", func(t *testing.T) {
-        release := Release{
-            Tracks: []*Track{},
+        release := model.Release{
+            Tracks: []*model.Track{},
         }
 
         t.Run("false when no tracks are present", func(t *testing.T) {
             assert.Equal(t, release.IsSingle(), false)
         })
 
-        release.Tracks = append(release.Tracks, &Track{})
+        release.Tracks = append(release.Tracks, &model.Track{})
         t.Run("true when one track is present", func(t *testing.T) {
             assert.Equal(t, release.IsSingle(), true)
         })
 
-        release.Tracks = append(release.Tracks, &Track{})
+        release.Tracks = append(release.Tracks, &model.Track{})
         t.Run("false when >1 tracks are present", func(t *testing.T) {
             assert.Equal(t, release.IsSingle(), false)
         })
     })
 
     t.Run("released", func(t *testing.T) {
-        release := Release {
+        release := model.Release {
             ReleaseDate: time.Now(),
         }
 
@@ -84,23 +85,23 @@ func Test_Release(t *testing.T) {
         artist3 := "idk"
         artist4 := "guest"
 
-        release := Release{}
+        release := model.Release{}
         t.Run("prints \"Unknown Artist\" when release has no credits", func(t *testing.T) {
             assert.Equal(t, release.PrintArtists(false, true), "Unknown Artist")
         })
 
         release.Credits = append(
             release.Credits, 
-            &Credit{ Artist: Artist{ Name: artist1 }, Primary: true },
+            &model.Credit{ Artist: &model.Artist{ Name: artist1 }, Primary: true },
         )
         t.Run("prints ONLY first artist name when release has one credit", func(t *testing.T) {
             assert.Equal(t, release.PrintArtists(false, true), artist1)
         })
 
-        release.Credits = append(release.Credits, []*Credit{
-                { Artist: Artist{ Name: artist2 }, Primary: true },
-                { Artist: Artist{ Name: artist3 }, Primary: false },
-                { Artist: Artist{ Name: artist4 }, Primary: true },
+        release.Credits = append(release.Credits, []*model.Credit{
+                { Artist: &model.Artist{ Name: artist2 }, Primary: true },
+                { Artist: &model.Artist{ Name: artist3 }, Primary: false },
+                { Artist: &model.Artist{ Name: artist4 }, Primary: true },
         }...)
         t.Run("can get only unique primary artist names", func(t *testing.T) {
             assert.Equal(
@@ -146,4 +147,37 @@ func Test_Release(t *testing.T) {
             )
         })
     })
+
+    t.Run("validating release types", func(t *testing.T) {
+        t.Run("single", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("single")
+            assert.Equal(t, ok, true)
+            assert.Equal(t, releaseType, model.Single)
+        })
+        t.Run("album", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("album")
+            assert.Equal(t, ok, true)
+            assert.Equal(t, releaseType, model.Album)
+        })
+        t.Run("EP", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("EP")
+            assert.Equal(t, ok, true)
+            assert.Equal(t, releaseType, model.EP)
+        })
+        t.Run("compilation", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("compilation")
+            assert.Equal(t, ok, true)
+            assert.Equal(t, releaseType, model.Compilation)
+        })
+        t.Run("upcoming", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("upcoming")
+            assert.Equal(t, ok, true)
+            assert.Equal(t, releaseType, model.Upcoming)
+        })
+        t.Run("invalid", func(t *testing.T) {
+            releaseType, ok := model.ValidReleaseType("invalid")
+            assert.Equal(t, ok, false)
+            assert.Equal(t, string(releaseType), "")
+        })
+    })
 }