HEAVY: finish music service migration, tidy up services, more tests
This commit is contained in:
parent
9e311df462
commit
90a671982c
GPG key ID:
CF99829C92678188
47 changed files with 2698 additions and 902 deletions
82
service/music/artist.go
Normal file
82
service/music/artist.go
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
package music
|
||||
|
||||
import (
|
||||
"arimelody-web/errors"
|
||||
"arimelody-web/model"
|
||||
"arimelody-web/service/validator"
|
||||
)
|
||||
|
||||
func (s *MusicService) GetAllArtists() ([]*model.Artist, error) {
|
||||
return s.repo.GetAllArtists()
|
||||
}
|
||||
func (s *MusicService) GetArtistCount() (int, error) {
|
||||
return s.repo.GetArtistCount()
|
||||
}
|
||||
func (s *MusicService) GetArtistByID(id string) (*model.Artist, error) {
|
||||
artist, err := s.repo.GetArtistByID(id)
|
||||
if err != nil { return nil, err }
|
||||
if artist == nil { return nil, errors.NewNotExistError("Artist does not exist") }
|
||||
return artist, nil
|
||||
}
|
||||
func (s *MusicService) GetArtistsNotOnRelease(releaseID string) ([]*model.Artist, error) {
|
||||
return s.repo.GetArtistsNotOnRelease(releaseID)
|
||||
}
|
||||
func (s *MusicService) GetArtistCredits(artistID string, showHidden bool) ([]*model.Credit, error) {
|
||||
return s.repo.GetArtistCredits(artistID, showHidden)
|
||||
}
|
||||
|
||||
func (s *MusicService) CreateArtist(
|
||||
id string,
|
||||
name string,
|
||||
website string,
|
||||
avatar string,
|
||||
) error {
|
||||
if len(id) == 0 { return errors.NewValidationError("Artist ID cannot be empty") }
|
||||
if !validator.ValidateID(id) { return errors.NewValidationError("Artist ID contains invalid characters") }
|
||||
if len(name) == 0 { return errors.NewValidationError("Artist name cannot be empty") }
|
||||
|
||||
if err := s.repo.CreateArtist(id, name, website, avatar); err != nil { return err }
|
||||
s.log.Printf("Created new artist '%s' (%s)", name, id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateArtist(artist *model.Artist) error {
|
||||
if len(artist.ID) == 0 { return errors.NewValidationError("Artist ID cannot be empty") }
|
||||
if !validator.ValidateID(artist.ID) { return errors.NewValidationError("Artist ID contains invalid characters") }
|
||||
if len(artist.Name) == 0 { return errors.NewValidationError("Artist name cannot be empty") }
|
||||
if err := s.repo.UpdateArtist(artist); err != nil { return err }
|
||||
s.log.Printf("Updated artist %s", artist.ID)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateArtistID(oldID string, newID string) error {
|
||||
if len(newID) == 0 { return errors.NewValidationError("Artist ID cannot be empty") }
|
||||
if !validator.ValidateID(newID) { return errors.NewValidationError("Artist ID contains invalid characters") }
|
||||
if err := s.repo.UpdateArtistID(oldID, newID); err != nil { return err }
|
||||
s.log.Printf("Updated artist ID %s to %s", oldID, newID)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateArtistName(id string, name string) error {
|
||||
if len(name) == 0 { return errors.NewValidationError("Artist name cannot be empty") }
|
||||
if err := s.repo.UpdateArtistName(id, name); err != nil { return err }
|
||||
s.log.Printf("Updated artist %s name to %s", id, name)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateArtistWebsite(id string, website string) error {
|
||||
if err := s.repo.UpdateArtistWebsite(id, website); err != nil { return err }
|
||||
s.log.Printf("Updated artist %s website to %s", id, website)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateArtistAvatar(id string, avatar string) error {
|
||||
if err := s.repo.UpdateArtistAvatar(id, avatar); err != nil { return err }
|
||||
s.log.Printf("Updated artist %s avatar to %s", id, avatar)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) DeleteArtist(id string) error {
|
||||
deletedID, err := s.repo.DeleteArtist(id)
|
||||
if err != nil { return err }
|
||||
if deletedID == "" { return errors.NewNotExistError("Artist does not exist") }
|
||||
s.log.Printf("Deleted artist %s", id)
|
||||
return nil
|
||||
}
|
||||
225
service/music/artist_test.go
Normal file
225
service/music/artist_test.go
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
package music_test
|
||||
|
||||
import (
|
||||
"arimelody-web/errors"
|
||||
"arimelody-web/model"
|
||||
repository "arimelody-web/repository/music"
|
||||
service "arimelody-web/service/music"
|
||||
"log"
|
||||
"os"
|
||||
"slices"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gotest.tools/v3/assert"
|
||||
)
|
||||
|
||||
func Test_Artist(t *testing.T) {
|
||||
devNullFile, err := os.OpenFile(os.DevNull, os.O_RDWR, 0666)
|
||||
if err != nil { panic(err) }
|
||||
defer devNullFile.Close()
|
||||
|
||||
repo := repository.NewMusicRepositoryMemory(
|
||||
make([]*model.Artist, 0),
|
||||
make([]*model.Release, 0),
|
||||
make([]*model.Track, 0),
|
||||
)
|
||||
s = service.NewMusicService(
|
||||
repo,
|
||||
log.New(devNullFile, "", model.DEFAULT_LOG_FLAGS),
|
||||
)
|
||||
|
||||
id := "cool-artist"
|
||||
name := "Cool Artist"
|
||||
website := "artist.arimelody.space"
|
||||
avatarURL := "/img/cool-artist.webp"
|
||||
|
||||
t.Run("artists should start empty", func(t *testing.T) {
|
||||
t.Run("count is zero", func(t *testing.T) {
|
||||
if num, err := s.GetArtistCount(); err != nil {
|
||||
t.Errorf("Failed to get number of artists: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 0)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("service returns empty array", func(t *testing.T) {
|
||||
if artists, err := s.GetAllArtists(); err != nil {
|
||||
t.Errorf("Failed to get artists: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(artists), 0)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can create artist", func(t *testing.T) {
|
||||
if err := s.CreateArtist(id, name, website, avatarURL); err != nil {
|
||||
t.Errorf("Failed to create artist: %v", err)
|
||||
}
|
||||
|
||||
t.Run("but not with an invalid ID", func(t *testing.T) {
|
||||
if err := s.CreateArtist("", name, website, avatarURL); err == nil {
|
||||
t.Error("Created artist with invalid ID")
|
||||
}
|
||||
})
|
||||
t.Run("but not with an invalid name", func(t *testing.T) {
|
||||
if err := s.CreateArtist("test-artist", "", website, avatarURL); err == nil {
|
||||
t.Error("Created artist with invalid name")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("and retrieve it", func(t *testing.T) {
|
||||
repoArtist, err := s.GetArtistByID(id)
|
||||
if err != nil { t.Errorf("Failed to get artist: %v", err) }
|
||||
|
||||
assert.Equal(t, repoArtist.ID, id)
|
||||
assert.Equal(t, repoArtist.Name, name)
|
||||
assert.Equal(t, repoArtist.Website, website)
|
||||
assert.Equal(t, repoArtist.Avatar, avatarURL)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("number of artists should increment", func(t *testing.T) {
|
||||
t.Run("count is one", func(t *testing.T) {
|
||||
if num, err := s.GetArtistCount(); err != nil {
|
||||
t.Errorf("Failed to get number of artists: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 1)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("service returns array with one artist", func(t *testing.T) {
|
||||
if artists, err := s.GetAllArtists(); err != nil {
|
||||
t.Errorf("Failed to get artists: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(artists), 1)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
releaseID := "test-release"
|
||||
t.Run("can get artists not on a release", func(t *testing.T) {
|
||||
if err := s.CreateRelease(releaseID, "test", string(model.Single), time.Now(), ""); err != nil {
|
||||
t.Errorf("Failed to create release: %v", err)
|
||||
}
|
||||
|
||||
artists, err := s.GetArtistsNotOnRelease(releaseID)
|
||||
if err != nil { t.Errorf("Failed to get artists: %v", err) }
|
||||
|
||||
assert.Assert(t, slices.ContainsFunc(artists, func(artist *model.Artist) bool {
|
||||
return artist.ID == id
|
||||
}))
|
||||
})
|
||||
|
||||
credit := &model.Credit{
|
||||
Artist: &model.Artist{ ID: id, Name: name, Website: website, Avatar: avatarURL },
|
||||
Role: "did a lot of stuff",
|
||||
Primary: true,
|
||||
}
|
||||
t.Run("can get artist credits", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseCredits(releaseID, []*model.Credit{ credit }); err != nil {
|
||||
t.Errorf("Failed to update release credits: %v", err)
|
||||
}
|
||||
|
||||
credits, err := s.GetArtistCredits(id, true)
|
||||
if err != nil { t.Errorf("Failed to get credits: %v", err) }
|
||||
|
||||
index := slices.IndexFunc(credits, func(credit *model.Credit) bool {
|
||||
return credit.Artist.ID == id
|
||||
})
|
||||
assert.Assert(t, index != -1)
|
||||
assert.Equal(t, credits[index].Artist.ID, id)
|
||||
assert.Equal(t, credits[index].Artist.Name, name)
|
||||
assert.Equal(t, credits[index].Artist.Website, website)
|
||||
assert.Equal(t, credits[index].Artist.Avatar, avatarURL)
|
||||
assert.Equal(t, credits[index].Role, credit.Role)
|
||||
assert.Equal(t, credits[index].Primary, credit.Primary)
|
||||
})
|
||||
|
||||
t.Run("can update artist", func(t *testing.T) {
|
||||
testName := "this name is only temporary"
|
||||
testWebsite := "https://test.example.org"
|
||||
testAvatar := "/img/test-avatar.webp"
|
||||
if err := s.UpdateArtist(&model.Artist{
|
||||
ID: id,
|
||||
Name: testName,
|
||||
Website: testWebsite,
|
||||
Avatar: testAvatar,
|
||||
}); err != nil {
|
||||
t.Errorf("Failed to update artist: %v", err)
|
||||
}
|
||||
|
||||
artist, err := s.GetArtistByID(id)
|
||||
if err != nil { t.Errorf("Failed to get artist: %v", err) }
|
||||
assert.Equal(t, artist.Name, testName)
|
||||
assert.Equal(t, artist.Website, testWebsite)
|
||||
assert.Equal(t, artist.GetAvatar(), testAvatar)
|
||||
|
||||
t.Run("but not with invalid name", func(t *testing.T) {
|
||||
if err := s.UpdateArtist(&model.Artist{
|
||||
ID: id,
|
||||
Name: "",
|
||||
}); err == nil {
|
||||
t.Errorf("Updated artist name to invalid value")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update artist name", func(t *testing.T) {
|
||||
if err := s.UpdateArtistName(id, name); err != nil {
|
||||
t.Errorf("Failed to update artist: %v", err)
|
||||
}
|
||||
|
||||
artist, err := s.GetArtistByID(id)
|
||||
if err != nil { t.Errorf("Failed to get artist: %v", err) }
|
||||
assert.Equal(t, artist.Name, name)
|
||||
|
||||
t.Run("but not with invalid value", func(t *testing.T) {
|
||||
if err := s.UpdateArtistName(id, ""); err == nil {
|
||||
t.Errorf("Updated artist name to invalid value")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update artist website", func(t *testing.T) {
|
||||
if err := s.UpdateArtistWebsite(id, website); err != nil {
|
||||
t.Errorf("Failed to update artist: %v", err)
|
||||
}
|
||||
|
||||
artist, err := s.GetArtistByID(id)
|
||||
if err != nil { t.Errorf("Failed to get artist: %v", err) }
|
||||
assert.Equal(t, artist.Website, website)
|
||||
})
|
||||
|
||||
t.Run("can update artist avatar", func(t *testing.T) {
|
||||
if err := s.UpdateArtistAvatar(id, ""); err != nil {
|
||||
t.Errorf("Failed to update artist: %v", err)
|
||||
}
|
||||
|
||||
artist, err := s.GetArtistByID(id)
|
||||
if err != nil { t.Errorf("Failed to get artist: %v", err) }
|
||||
assert.Equal(t, artist.GetAvatar(), model.DEFAULT_AVATAR_URL)
|
||||
})
|
||||
|
||||
t.Run("can delete artist", func(t *testing.T) {
|
||||
if err := s.DeleteArtist(id); err != nil {
|
||||
t.Errorf("Failed to delete artist: %v", err)
|
||||
}
|
||||
|
||||
t.Run("no longer exists", func(t *testing.T) {
|
||||
if artist, err := s.GetArtistByID(id); err == nil {
|
||||
t.Error("No error getting artist")
|
||||
} else if artist != nil {
|
||||
t.Error("Artist with this ID still exists")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("but not one that doesn't exist", func(t *testing.T) {
|
||||
if err := s.DeleteArtist("some-garbage-id"); err == nil {
|
||||
if !errors.IsNotExistError(err) {
|
||||
t.Errorf("Failed to delete artist: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
18
service/music/music.go
Normal file
18
service/music/music.go
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
package music
|
||||
|
||||
import (
|
||||
repository "arimelody-web/repository/music"
|
||||
"log"
|
||||
)
|
||||
|
||||
type MusicService struct {
|
||||
repo repository.MusicRepository
|
||||
log *log.Logger
|
||||
}
|
||||
|
||||
func NewMusicService(repo repository.MusicRepository, logger *log.Logger) *MusicService {
|
||||
return &MusicService{
|
||||
repo: repo,
|
||||
log: logger,
|
||||
}
|
||||
}
|
||||
9
service/music/music_test.go
Normal file
9
service/music/music_test.go
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
package music_test
|
||||
|
||||
import (
|
||||
service "arimelody-web/service/music"
|
||||
)
|
||||
|
||||
var (
|
||||
s *service.MusicService
|
||||
)
|
||||
180
service/music/release.go
Normal file
180
service/music/release.go
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
package music
|
||||
|
||||
import (
|
||||
"arimelody-web/errors"
|
||||
"arimelody-web/model"
|
||||
"arimelody-web/service/validator"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Hydrates a release with its additional data (credits, tracks, links)
|
||||
func (s *MusicService) fillRelease(release *model.Release) error {
|
||||
credits, err := s.GetReleaseCredits(release.ID)
|
||||
if err != nil { return fmt.Errorf("credits: %s", err) }
|
||||
release.Credits = append(release.Credits, credits...)
|
||||
|
||||
tracks, err := s.GetReleaseTracks(release.ID)
|
||||
if err != nil { return fmt.Errorf("tracks: %s", err) }
|
||||
release.Tracks = append(release.Tracks, tracks...)
|
||||
|
||||
links, err := s.GetReleaseLinks(release.ID)
|
||||
if err != nil { return fmt.Errorf("links: %s", err) }
|
||||
release.Links = append(release.Links, links...)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) GetAllReleases(onlyVisible bool, limit int) ([]*model.Release, error) {
|
||||
return s.repo.GetAllReleases(onlyVisible, limit)
|
||||
}
|
||||
|
||||
func (s *MusicService) GetAllFullReleases(onlyVisible bool, limit int) ([]*model.Release, error) {
|
||||
releases, err := s.repo.GetAllReleases(onlyVisible, limit)
|
||||
if err != nil { return nil, err }
|
||||
for _, release := range releases {
|
||||
if err := s.fillRelease(release); err != nil { return nil, err }
|
||||
}
|
||||
return releases, nil
|
||||
}
|
||||
|
||||
func (s *MusicService) GetReleaseCount(onlyVisible bool) (int, error) {
|
||||
return s.repo.GetReleaseCount(onlyVisible)
|
||||
}
|
||||
|
||||
func (s *MusicService) GetReleaseByID(id string) (*model.Release, error) {
|
||||
release, err := s.repo.GetReleaseByID(id)
|
||||
if err != nil { return nil, err }
|
||||
if release == nil { return nil, errors.NewNotExistError("Release does not exist") }
|
||||
return release, nil
|
||||
}
|
||||
|
||||
func (s *MusicService) GetFullReleaseByID(id string) (*model.Release, error) {
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { return nil, err }
|
||||
if err := s.fillRelease(release); err != nil { return nil, err }
|
||||
return release, nil
|
||||
}
|
||||
|
||||
func (s *MusicService) GetReleaseTracks(id string) ([]*model.Track, error) {
|
||||
return s.repo.GetReleaseTracks(id)
|
||||
}
|
||||
func (s *MusicService) GetReleaseCredits(id string) ([]*model.Credit, error) {
|
||||
return s.repo.GetReleaseCredits(id)
|
||||
}
|
||||
func (s *MusicService) GetReleaseLinks(id string) ([]*model.Link, error) {
|
||||
return s.repo.GetReleaseLinks(id)
|
||||
}
|
||||
|
||||
func (s *MusicService) CreateRelease(
|
||||
id string,
|
||||
title string,
|
||||
releaseType string,
|
||||
releaseDate time.Time,
|
||||
artworkURL string,
|
||||
) error {
|
||||
if len(id) == 0 { return errors.NewValidationError("Release ID cannot be empty") }
|
||||
if !validator.ValidateID(id) { return errors.NewValidationError("Release ID contains invalid characters") }
|
||||
if len(title) == 0 { return errors.NewValidationError("Release title cannot be empty") }
|
||||
validReleaseType, ok := model.ValidReleaseType(releaseType)
|
||||
if !ok { return errors.NewValidationError("Invalid release type") }
|
||||
|
||||
if err := s.repo.CreateRelease(id, title, validReleaseType, releaseDate, artworkURL); err != nil { return err }
|
||||
s.log.Printf("Created new release '%s' (%s)", title, id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateRelease(release *model.Release) error {
|
||||
if len(release.ID) == 0 { return errors.NewValidationError("Release ID cannot be empty") }
|
||||
if !validator.ValidateID(release.ID) { return errors.NewValidationError("Release ID contains invalid characters") }
|
||||
if len(release.Title) == 0 { return errors.NewValidationError("Release title cannot be empty") }
|
||||
|
||||
if err := s.repo.UpdateRelease(release); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' (%s)", release.Title, release.ID)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseID(oldID string, newID string) error {
|
||||
if len(newID) == 0 { return errors.NewValidationError("Release ID cannot be empty") }
|
||||
if !validator.ValidateID(newID) { return errors.NewValidationError("Release ID contains invalid characters") }
|
||||
if err := s.repo.UpdateReleaseID(oldID, newID); err != nil { return err }
|
||||
s.log.Printf("Updated release ID %s to %s", oldID, newID)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseVisibility(id string, visible bool) error {
|
||||
if err := s.repo.UpdateReleaseVisibility(id, visible); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' visibility to %t", id, visible)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseTitle(id string, title string) error {
|
||||
if len(title) == 0 { return errors.NewValidationError("Release title cannot be empty") }
|
||||
if err := s.repo.UpdateReleaseTitle(id, title); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' title to %s", id, title)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseDescription(id string, description string) error {
|
||||
if err := s.repo.UpdateReleaseDescription(id, description); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' description to %s", id, description)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseType(id string, releaseType string) error {
|
||||
validReleaseType, ok := model.ValidReleaseType(releaseType)
|
||||
if !ok { return errors.NewValidationError("Invalid release type") }
|
||||
if err := s.repo.UpdateReleaseType(id, validReleaseType); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' type to %s", id, releaseType)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseDate(id string, releaseDate time.Time) error {
|
||||
if err := s.repo.UpdateReleaseDate(id, releaseDate); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' date to %s", id, releaseDate.Format(time.RFC3339))
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseArtwork(id string, artwork string) error {
|
||||
if err := s.repo.UpdateReleaseArtwork(id, artwork); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' artwork to %s", id, artwork)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseBuyInfo(id string, buyName string, buyLink string) error {
|
||||
if err := s.repo.UpdateReleaseBuyInfo(id, buyName, buyLink); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' buy info (name='%s', link='%s')", id, buyName, buyLink)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateReleaseCopyright(id string, copyright string, url string) error {
|
||||
if err := s.repo.UpdateReleaseCopyright(id, copyright, url); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' copyright (copyright='%s', url='%s')", id, copyright, url)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateReleaseTracks(id string, newTrackIDs []string) error {
|
||||
for _, id := range newTrackIDs {
|
||||
if len(id) == 0 { return errors.NewValidationError("Track IDs cannot be empty") }
|
||||
}
|
||||
|
||||
if err := s.repo.UpdateReleaseTracks(id, newTrackIDs); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' tracks (%d tracks)", id, len(newTrackIDs))
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateReleaseCredits(id string, newCredits []*model.Credit) error {
|
||||
if err := s.repo.UpdateReleaseCredits(id, newCredits); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' credits (%d credits)", id, len(newCredits))
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateReleaseLinks(id string, newLinks []*model.Link) error {
|
||||
for _, link := range newLinks {
|
||||
if len(link.Name) == 0 { return errors.NewValidationError("Link names cannot be empty") }
|
||||
if len(link.URL) == 0 { return errors.NewValidationError("Link URLs cannot be empty") }
|
||||
}
|
||||
|
||||
if err := s.repo.UpdateReleaseLinks(id, newLinks); err != nil { return err }
|
||||
s.log.Printf("Updated release '%s' links (%d links)", id, len(newLinks))
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) DeleteRelease(id string) error {
|
||||
deletedID, err := s.repo.DeleteRelease(id)
|
||||
if err != nil { return err }
|
||||
if deletedID == "" { return errors.NewNotExistError("Release does not exist") }
|
||||
s.log.Printf("Deleted release '%s'", id)
|
||||
return nil
|
||||
}
|
||||
374
service/music/release_test.go
Normal file
374
service/music/release_test.go
Normal file
|
|
@ -0,0 +1,374 @@
|
|||
package music_test
|
||||
|
||||
import (
|
||||
"arimelody-web/errors"
|
||||
"arimelody-web/model"
|
||||
repository "arimelody-web/repository/music"
|
||||
service "arimelody-web/service/music"
|
||||
"log"
|
||||
"os"
|
||||
"slices"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gotest.tools/v3/assert"
|
||||
)
|
||||
|
||||
func Test_Release(t *testing.T) {
|
||||
devNullFile, err := os.OpenFile(os.DevNull, os.O_RDWR, 0666)
|
||||
if err != nil { panic(err) }
|
||||
defer devNullFile.Close()
|
||||
|
||||
repo := repository.NewMusicRepositoryMemory(
|
||||
make([]*model.Artist, 0),
|
||||
make([]*model.Release, 0),
|
||||
make([]*model.Track, 0),
|
||||
)
|
||||
s = service.NewMusicService(
|
||||
repo,
|
||||
log.New(devNullFile, "", model.DEFAULT_LOG_FLAGS),
|
||||
)
|
||||
|
||||
id := "cool-release"
|
||||
title := "Cool Release"
|
||||
releaseType := model.Album
|
||||
releaseDate := time.Now()
|
||||
artworkURL := "/img/some-cool-artwork.webp"
|
||||
|
||||
t.Run("releases should start empty", func(t *testing.T) {
|
||||
t.Run("count is zero", func(t *testing.T) {
|
||||
if num, err := s.GetReleaseCount(false); err != nil {
|
||||
t.Errorf("Failed to get number of releases: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 0)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("service returns empty array", func(t *testing.T) {
|
||||
if releases, err := s.GetAllReleases(false, 0); err != nil {
|
||||
t.Errorf("Failed to get releases: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(releases), 0)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can create release", func(t *testing.T) {
|
||||
if err := s.CreateRelease(id, title, string(releaseType), releaseDate, artworkURL); err != nil {
|
||||
t.Errorf("Failed to create release: %v", err)
|
||||
}
|
||||
|
||||
t.Run("but not with an invalid ID", func(t *testing.T) {
|
||||
if err := s.CreateRelease("", title, string(releaseType), releaseDate, artworkURL); err == nil {
|
||||
t.Error("Created release with invalid ID")
|
||||
}
|
||||
})
|
||||
t.Run("but not with an invalid title", func(t *testing.T) {
|
||||
if err := s.CreateRelease("test-release", "", string(releaseType), releaseDate, artworkURL); err == nil {
|
||||
t.Error("Created release with invalid title")
|
||||
}
|
||||
})
|
||||
t.Run("but not with an invalid type", func(t *testing.T) {
|
||||
if err := s.CreateRelease("test-release", "", "garbage-type", releaseDate, artworkURL); err == nil {
|
||||
t.Error("Created release with invalid type")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("and retrieve it", func(t *testing.T) {
|
||||
repoRelease, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if repoRelease == nil { t.Error("Release does not exist") }
|
||||
|
||||
assert.Equal(t, repoRelease.ID, id)
|
||||
assert.Equal(t, repoRelease.Title, title)
|
||||
assert.Equal(t, repoRelease.ReleaseType, releaseType)
|
||||
assert.Equal(t, repoRelease.ReleaseDate, releaseDate)
|
||||
assert.Equal(t, repoRelease.GetArtwork(), artworkURL)
|
||||
})
|
||||
|
||||
t.Run("should not be visible by default", func(t *testing.T) {
|
||||
releases, err := s.GetAllReleases(true, 0)
|
||||
if err != nil { t.Errorf("Failed to get releases: %v", err) }
|
||||
|
||||
assert.Equal(t, slices.ContainsFunc(releases, func(release *model.Release) bool {
|
||||
return release.ID == id
|
||||
}), false)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("number of releases should increment", func(t *testing.T) {
|
||||
t.Run("count is one", func(t *testing.T) {
|
||||
if num, err := s.GetReleaseCount(false); err != nil {
|
||||
t.Errorf("Failed to get number of releases: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 1)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("service returns array with one release", func(t *testing.T) {
|
||||
if releases, err := s.GetAllReleases(false, 0); err != nil {
|
||||
t.Errorf("Failed to get releases: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(releases), 1)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update release", func(t *testing.T) {
|
||||
testTitle := "this title is only temporary"
|
||||
testReleaseType := model.Compilation
|
||||
testReleaseDate := time.Now().AddDate(0, 0, 10)
|
||||
testArtworkURL := "/img/test-artwork.webp"
|
||||
if err := s.UpdateRelease(&model.Release{
|
||||
ID: id,
|
||||
Title: testTitle,
|
||||
ReleaseType: testReleaseType,
|
||||
ReleaseDate: testReleaseDate,
|
||||
Artwork: testArtworkURL,
|
||||
}); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Title, testTitle)
|
||||
assert.Equal(t, release.ReleaseType, testReleaseType)
|
||||
assert.Equal(t, release.ReleaseDate, testReleaseDate)
|
||||
assert.Equal(t, release.GetArtwork(), testArtworkURL)
|
||||
|
||||
t.Run("but not with invalid title", func(t *testing.T) {
|
||||
if err := s.UpdateRelease(&model.Release{
|
||||
ID: id,
|
||||
Title: "",
|
||||
}); err == nil {
|
||||
t.Errorf("Updated release title to invalid value")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update visibility", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseVisibility(id, true); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Visible, true)
|
||||
|
||||
t.Run("should be visible after updating", func(t *testing.T) {
|
||||
releases, err := s.GetAllReleases(true, 0)
|
||||
if err != nil { t.Errorf("Failed to get releases: %v", err) }
|
||||
|
||||
assert.Equal(t, slices.ContainsFunc(releases, func(release *model.Release) bool {
|
||||
return release.ID == id
|
||||
}), true)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update title", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseTitle(id, title); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Title, title)
|
||||
|
||||
t.Run("but not with invalid value", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseTitle(id, ""); err == nil {
|
||||
t.Errorf("Updated release title to invalid value")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update description", func(t *testing.T) {
|
||||
testDescription := "an incredible and thought-provoking description"
|
||||
if err := s.UpdateReleaseDescription(id, testDescription); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Description, testDescription)
|
||||
})
|
||||
|
||||
t.Run("can update type", func(t *testing.T) {
|
||||
testType := model.EP
|
||||
if err := s.UpdateReleaseType(id, string(testType)); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.ReleaseType, testType)
|
||||
releaseType = testType
|
||||
|
||||
t.Run("but not with invalid value", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseType(id, "garbage-type"); err == nil {
|
||||
t.Errorf("Updated release type to invalid value")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can update date", func(t *testing.T) {
|
||||
testDate := time.Now().Add(time.Hour * 24)
|
||||
if err := s.UpdateReleaseDate(id, testDate); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.ReleaseDate, testDate)
|
||||
releaseDate = testDate
|
||||
})
|
||||
|
||||
t.Run("can update artwork", func(t *testing.T) {
|
||||
if err := s.UpdateReleaseArtwork(id, ""); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.GetArtwork(), model.DEFAULT_RELEASE_ARTWORK_URL)
|
||||
})
|
||||
|
||||
t.Run("can update buy info", func(t *testing.T) {
|
||||
testBuyName := "get it now!!!"
|
||||
testBuyLink := "https://arimelody.space/music"
|
||||
if err := s.UpdateReleaseBuyInfo(id, testBuyName, testBuyLink); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Buyname, testBuyName)
|
||||
assert.Equal(t, release.Buylink, testBuyLink)
|
||||
})
|
||||
|
||||
t.Run("can update copyright info", func(t *testing.T) {
|
||||
testCopyright := "CC BY-SA 4.0"
|
||||
testCopyrightURL := "https://creativecommons.org/licenses/by-sa/4.0/"
|
||||
if err := s.UpdateReleaseCopyright(id, testCopyright, testCopyrightURL); err != nil {
|
||||
t.Errorf("Failed to update release: %v", err)
|
||||
}
|
||||
|
||||
release, err := s.GetReleaseByID(id)
|
||||
if err != nil { t.Errorf("Failed to get release: %v", err) }
|
||||
if release == nil { t.Error("Release does not exist after update") }
|
||||
assert.Equal(t, release.Copyright, testCopyright)
|
||||
assert.Equal(t, release.CopyrightURL, testCopyrightURL)
|
||||
})
|
||||
|
||||
track := &model.Track{
|
||||
Title: "test track",
|
||||
Description: "average description",
|
||||
Lyrics: "some lyrics",
|
||||
}
|
||||
t.Run("can update tracks", func(t *testing.T) {
|
||||
if trackID, err := s.CreateTrack(track.Title, track.Description, track.Lyrics, ""); err != nil {
|
||||
t.Errorf("Failed to create track: %v", err)
|
||||
} else { track.ID = trackID }
|
||||
|
||||
if err := s.UpdateReleaseTracks(id, []string{ track.ID }); err != nil {
|
||||
t.Errorf("Failed to update release tracks: %v", err)
|
||||
}
|
||||
|
||||
tracks, err := s.GetReleaseTracks(id)
|
||||
if err != nil { t.Errorf("Failed to get tracks: %v", err) }
|
||||
|
||||
index := slices.IndexFunc(tracks, func(repoTrack *model.Track) bool {
|
||||
return repoTrack.ID == track.ID
|
||||
})
|
||||
assert.Assert(t, index != -1)
|
||||
assert.Equal(t, tracks[index].Title, track.Title)
|
||||
assert.Equal(t, tracks[index].Description, track.Description)
|
||||
assert.Equal(t, tracks[index].Lyrics, track.Lyrics)
|
||||
})
|
||||
|
||||
t.Run("can update credits", func(t *testing.T) {
|
||||
artist := &model.Artist{ ID: id, Name: title, Website: "", Avatar: "" }
|
||||
if err := s.CreateArtist(artist.ID, artist.Name, artist.Website, artist.Avatar); err != nil {
|
||||
t.Errorf("Failed to create artist: %v", err)
|
||||
}
|
||||
|
||||
credit := &model.Credit{
|
||||
Artist: artist,
|
||||
Role: "did a lot of stuff",
|
||||
Primary: true,
|
||||
}
|
||||
|
||||
if err := s.UpdateReleaseCredits(id, []*model.Credit{ credit }); err != nil {
|
||||
t.Errorf("Failed to update release credits: %v", err)
|
||||
}
|
||||
|
||||
credits, err := s.GetReleaseCredits(id)
|
||||
if err != nil { t.Errorf("Failed to get credits: %v", err) }
|
||||
assert.Equal(t, len(credits), 1)
|
||||
|
||||
index := slices.IndexFunc(credits, func(repoCredit *model.Credit) bool {
|
||||
return repoCredit.Artist.ID == credit.Artist.ID
|
||||
})
|
||||
assert.Assert(t, index != -1)
|
||||
assert.Equal(t, credits[index].Release.ID, id)
|
||||
assert.Equal(t, credits[index].Release.Title, title)
|
||||
assert.Equal(t, credits[index].Release.ReleaseType, releaseType)
|
||||
assert.Equal(t, credits[index].Release.ReleaseDate, releaseDate)
|
||||
assert.Equal(t, credits[index].Release.GetArtwork(), model.DEFAULT_RELEASE_ARTWORK_URL)
|
||||
assert.Equal(t, credits[index].Artist.ID, credit.Artist.ID)
|
||||
assert.Equal(t, credits[index].Artist.Name, credit.Artist.Name)
|
||||
assert.Equal(t, credits[index].Artist.Website, credit.Artist.Website)
|
||||
assert.Equal(t, credits[index].Artist.GetAvatar(), credit.Artist.GetAvatar())
|
||||
assert.Equal(t, credits[index].Role, credit.Role)
|
||||
assert.Equal(t, credits[index].Primary, credit.Primary)
|
||||
})
|
||||
|
||||
t.Run("can update links", func(t *testing.T) {
|
||||
link := &model.Link{
|
||||
Name: "awesome link you should totally go here",
|
||||
URL: "https://arimelody.space",
|
||||
}
|
||||
|
||||
if err := s.UpdateReleaseLinks(id, []*model.Link{ link }); err != nil {
|
||||
t.Errorf("Failed to update release tracks: %v", err)
|
||||
}
|
||||
|
||||
links, err := s.GetReleaseLinks(id)
|
||||
if err != nil { t.Errorf("Failed to get tracks: %v", err) }
|
||||
|
||||
index := slices.IndexFunc(links, func(repoLink *model.Link) bool {
|
||||
return repoLink.Name == link.Name
|
||||
})
|
||||
assert.Assert(t, index != -1)
|
||||
assert.Equal(t, links[index].URL, link.URL)
|
||||
})
|
||||
|
||||
t.Run("can delete release", func(t *testing.T) {
|
||||
if err := s.DeleteRelease(id); err != nil {
|
||||
t.Errorf("Failed to delete release: %v", err)
|
||||
}
|
||||
|
||||
t.Run("no longer exists", func(t *testing.T) {
|
||||
if release, err := s.GetReleaseByID(id); err == nil {
|
||||
t.Error("No error getting release")
|
||||
} else if release != nil {
|
||||
t.Error("Release with this ID still exists")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("but not one that doesn't exist", func(t *testing.T) {
|
||||
if err := s.DeleteRelease("some-garbage-id"); err == nil {
|
||||
if !errors.IsNotExistError(err) {
|
||||
t.Errorf("Failed to delete release: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
81
service/music/track.go
Normal file
81
service/music/track.go
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
package music
|
||||
|
||||
import (
|
||||
"arimelody-web/model"
|
||||
"arimelody-web/errors"
|
||||
)
|
||||
|
||||
|
||||
func (s *MusicService) GetAllTracks() ([]*model.Track, error) {
|
||||
return s.repo.GetAllTracks()
|
||||
}
|
||||
func (s *MusicService) GetTrackCount() (int, error) {
|
||||
return s.repo.GetTrackCount()
|
||||
}
|
||||
func (s *MusicService) GetTrackByID(id string) (*model.Track, error) {
|
||||
track, err := s.repo.GetTrackByID(id)
|
||||
if err != nil { return nil, err }
|
||||
if track == nil { return nil, errors.NewNotExistError("Track does not exist") }
|
||||
return track, nil
|
||||
}
|
||||
func (s *MusicService) GetOrphanTracks() ([]*model.Track, error) {
|
||||
return s.repo.GetOrphanTracks()
|
||||
}
|
||||
func (s *MusicService) GetTracksNotOnRelease(releaseID string) ([]*model.Track, error) {
|
||||
return s.repo.GetTracksNotOnRelease(releaseID)
|
||||
}
|
||||
func (s *MusicService) GetTrackReleases(trackID string) ([]*model.Release, error) {
|
||||
return s.repo.GetTrackReleases(trackID)
|
||||
}
|
||||
func (s *MusicService) GetTrackFullReleases(trackID string) ([]*model.Release, error) {
|
||||
releases, err := s.GetTrackReleases(trackID)
|
||||
if err != nil { return nil, err }
|
||||
for _, release := range releases {
|
||||
if err := s.fillRelease(release); err != nil { return nil, err }
|
||||
}
|
||||
return releases, nil
|
||||
}
|
||||
|
||||
func (s *MusicService) CreateTrack(title string, description string, lyrics string, previewURL string) (string, error) {
|
||||
if len(title) == 0 { return "", errors.NewValidationError("Track title cannot be empty") }
|
||||
id, err := s.repo.CreateTrack(title, description, lyrics, previewURL)
|
||||
if err != nil { return "", err }
|
||||
s.log.Printf("Created track '%s' (%s)", title, id)
|
||||
return id, nil
|
||||
}
|
||||
|
||||
func (s *MusicService) UpdateTrack(track *model.Track) error {
|
||||
if len(track.Title) == 0 { return errors.NewValidationError("Track title cannot be empty") }
|
||||
if err := s.repo.UpdateTrack(track); err != nil { return err }
|
||||
s.log.Printf("Updated track '%s' (%s)", track.Title, track.ID)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateTrackTitle(id string, title string) error {
|
||||
if len(title) == 0 { return errors.NewValidationError("Track title cannot be empty") }
|
||||
if err := s.repo.UpdateTrackTitle(id, title); err != nil { return err }
|
||||
s.log.Printf("Updated track %s title to '%s'", id, title)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateTrackDescription(id string, description string) error {
|
||||
if err := s.repo.UpdateTrackDescription(id, description); err != nil { return err }
|
||||
s.log.Printf("Updated track %s description to '%s'", id, description)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateTrackLyrics(id string, lyrics string) error {
|
||||
if err := s.repo.UpdateTrackLyrics(id, lyrics); err != nil { return err }
|
||||
s.log.Printf("Updated track %s lyrics to '%s'", id, lyrics)
|
||||
return nil
|
||||
}
|
||||
func (s *MusicService) UpdateTrackPreviewURL(id string, previewURL string) error {
|
||||
if err := s.repo.UpdateTrackPreviewURL(id, previewURL); err != nil { return err }
|
||||
s.log.Printf("Updated track %s preview URL to '%s'", id, previewURL)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *MusicService) DeleteTrack(id string) error {
|
||||
deletedID, err := s.repo.DeleteTrack(id)
|
||||
if err != nil { return err }
|
||||
if deletedID == "" { return errors.NewNotExistError("Track does not exist") }
|
||||
s.log.Printf("Deleted track %s", id)
|
||||
return nil
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue