refreshed release model tests: 100% coverage!

model/release_test.go

@@ -1,157 +1,149 @@
 package model
 
 import (
+	"strings"
 	"testing"
 	"time"
+
+	"gotest.tools/v3/assert"
 )
 
-func Test_Release_DescriptionHTML(t *testing.T) {
+func Test_Release(t *testing.T) {
+    t.Run("prints correct description HTML", func(t *testing.T) {
         release := Release{
             Description: "this is\na test\n<strong>description!</strong>",
         }
 
         // descriptions are set by privileged users,
         // so we'll allow HTML injection here
-    want := "this is<br>a test<br><strong>description!</strong>"
+        assert.Equal(
-    got := release.GetDescriptionHTML()
+            t,
-    if want != string(got) {
+            string(release.GetDescriptionHTML()),
-        t.Errorf(`release description incorrectly formatted (want "%s", got "%s")`, want, got)
+            "this is<br>a test<br><strong>description!</strong>",
-    }
+        )
-}
+    })
 
-func Test_Release_ReleaseDate(t *testing.T) {
+    t.Run("prints correct release date", func(t *testing.T) {
         release := Release{
             ReleaseDate: time.Date(2025, time.July, 26, 16, 0, 0, 0, time.UTC),
         }
 
-    want := "2025-07-26T16:00"
+        assert.Equal(t, release.TextReleaseDate(), "2025-07-26T16:00")
-    got := release.TextReleaseDate()
+        assert.Equal(t, release.PrintReleaseDate(), "26 July 2025")
-    if want != got {
+    })
-        t.Errorf(`release date incorrectly formatted (want "%s", got "%s")`, want, got)
-    }
 
-    want = "26 July 2025"
+    t.Run("returns correct artwork", func(t *testing.T) {
-    got = release.PrintReleaseDate()
+        artwork := "testartwork.png"
-    if want != got {
+        release := Release{ Artwork: artwork }
-        t.Errorf(`release date (print) incorrectly formatted (want "%s", got "%s")`, want, got)
+        assert.Equal(t, release.GetArtwork(), artwork)
-    }
+    })
-}
 
-func Test_Release_Artwork(t *testing.T) {
+    t.Run("returns placeholder artwork when empty", func(t *testing.T) {
-    want := "testartwork.png"
+        release := Release{}
-    release := Release{ Artwork: want }
+        assert.Equal(t, release.GetArtwork(), "/img/default-cover-art.png")
+    })
 
-    got := release.GetArtwork()
+    t.Run("singles", func(t *testing.T) {
-    if want != got {
-        t.Errorf(`correct value not returned when artwork is populated (want "%s", got "%s")`, want, got)
-    }
-
-    release = Release{}
-
-    want = "/img/default-cover-art.png" 
-    got = release.GetArtwork()
-    if want != got {
-        t.Errorf(`default value not returned when artwork is empty (want "%s", got "%s")`, want, got)
-    }
-}
-
-func Test_Release_IsSingle(t *testing.T) {
         release := Release{
             Tracks: []*Track{},
         }
 
-    if release.IsSingle() {
+        t.Run("false when no tracks are present", func(t *testing.T) {
-        t.Errorf("IsSingle() == true when no tracks are present")
+            assert.Equal(t, release.IsSingle(), false)
-    }
+        })
 
         release.Tracks = append(release.Tracks, &Track{})
-    if !release.IsSingle() {
+        t.Run("true when one track is present", func(t *testing.T) {
-        t.Errorf("IsSingle() == false when one track is present")
+            assert.Equal(t, release.IsSingle(), true)
-    }
+        })
 
         release.Tracks = append(release.Tracks, &Track{})
-    if release.IsSingle() {
+        t.Run("false when >1 tracks are present", func(t *testing.T) {
-        t.Errorf("IsSingle() == true when >1 tracks are present")
+            assert.Equal(t, release.IsSingle(), false)
-    }
+        })
-}
+    })
 
-func Test_Release_IsReleased(t *testing.T) {
+    t.Run("released", func(t *testing.T) {
         release := Release {
             ReleaseDate: time.Now(),
         }
 
-    if !release.IsReleased() {
+        t.Run("true when release date in the past", func(t *testing.T) {
-        t.Errorf("IsRelease() == false when release date in the past")
+            assert.Equal(t, release.IsReleased(), true)
-    }
+        })
 
         release.ReleaseDate = time.Now().Add(time.Hour)
-    if release.IsReleased() {
+        t.Run("false when release date in the future", func(t *testing.T) {
-        t.Errorf("IsRelease() == true when release date in the future")
+            assert.Equal(t, release.IsReleased(), false)
-    }
+        })
-}
+    })
 
-func Test_Release_PrintArtists(t *testing.T) {
+    t.Run("printing artists", func(t *testing.T) {
         artist1 := "ari melody"
         artist2 := "aridoodle"
         artist3 := "idk"
         artist4 := "guest"
 
-    release := Release {
+        release := Release{}
-        Credits: []*Credit{
+        t.Run("prints \"Unknown Artist\" when release has no credits", func(t *testing.T) {
-            { Artist: Artist{ Name: artist1 }, Primary: true },
+            assert.Equal(t, release.PrintArtists(false, true), "Unknown Artist")
+        })
+
+        release.Credits = append(
+            release.Credits, 
+            &Credit{ Artist: 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 },
-        },
+        }...)
-    }
+        t.Run("can get only unique primary artist names", func(t *testing.T) {
+            assert.Equal(
+                t,
+                strings.Join(release.GetUniqueArtistNames(true), " "),
+                strings.Join([]string{ artist1, artist2, artist4 }, " "),
+            )
+        })
+        t.Run("can get only unique artist names", func(t *testing.T) {
+            assert.Equal(
+                t,
+                strings.Join(release.GetUniqueArtistNames(false), " "),
+                strings.Join([]string{ artist1, artist2, artist3, artist4 }, " "),
+            )
+        })
 
-    {
+        t.Run("can print only primary artists, with ampersands", func(t *testing.T) {
-        want := []string{ artist1, artist2, artist4 }
+            assert.Equal(
-        got := release.GetUniqueArtistNames(true)
+                t,
-        if len(want) != len(got) {
+                release.PrintArtists(true, true),
-            t.Errorf(`len(GetUniqueArtistNames) (primary only) == %d, want %d`, len(got), len(want))
+                "ari melody, aridoodle & guest",
-        }
+            )
-        for i := range got {
+        })
-            if want[i] != got[i] {
+        t.Run("can print only primary artists, without ampersands", func(t *testing.T) {
-                t.Errorf(`GetUniqueArtistNames[%d] (primary only) == %s, want %s`, i, got[i], want[i])
+            assert.Equal(
-            }
+                t,
-        }
+                release.PrintArtists(true, false),
-
+                "ari melody, aridoodle, guest",
-        want = []string{ artist1, artist2, artist3, artist4 }
+            )
-        got = release.GetUniqueArtistNames(false)
+        })
-        if len(want) != len(got) {
+        t.Run("can print all artists, with ampersands", func(t *testing.T) {
-            t.Errorf(`len(GetUniqueArtistNames) == %d, want %d`, len(got), len(want))
+            assert.Equal(
-        }
+                t,
-        for i := range got {
+                release.PrintArtists(false, true),
-            if want[i] != got[i] {
+                "ari melody, aridoodle, idk & guest",
-                t.Errorf(`GetUniqueArtistNames[%d] == %s, want %s`, i, got[i], want[i])
+            )
-            }
+        })
-        }
+        t.Run("can print all artists, without ampersands", func(t *testing.T) {
-    }
+            assert.Equal(
-
+                t,
-    {
+                release.PrintArtists(false, false),
-        want := "ari melody, aridoodle & guest"
+                "ari melody, aridoodle, idk, guest",
-        got := release.PrintArtists(true, true)
+            )
-        if want != got {
+        })
-            t.Errorf(`PrintArtists (primary only, ampersand) == "%s", want "%s"`, want, got)
+    })
-        }
-
-        want = "ari melody, aridoodle, guest"
-        got = release.PrintArtists(true, false)
-        if want != got {
-            t.Errorf(`PrintArtists (primary only) == "%s", want "%s"`, want, got)
-        }
-
-        want = "ari melody, aridoodle, idk & guest"
-        got = release.PrintArtists(false, true)
-        if want != got {
-            t.Errorf(`PrintArtists (all, ampersand) == "%s", want "%s"`, want, got)
-        }
-
-        want = "ari melody, aridoodle, idk, guest"
-        got = release.PrintArtists(false, false)
-        if want != got {
-            t.Errorf(`PrintArtists (all) == "%s", want "%s"`, want, got)
-        }
-    }
 }