refreshed release model tests: 100% coverage!

This commit is contained in:
ari melody 2026-07-31 05:14:19 +01:00
parent 8be785cd8b
commit 89a5fdc4e5
Signed by: ari
GPG key ID: CF99829C92678188

View file

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