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
|
|
@ -1,10 +1,10 @@
|
|||
package account
|
||||
|
||||
import (
|
||||
"arimelody-web/errors"
|
||||
"arimelody-web/model"
|
||||
repository "arimelody-web/repository/account"
|
||||
"errors"
|
||||
"fmt"
|
||||
"arimelody-web/service/validator"
|
||||
"log"
|
||||
)
|
||||
|
||||
|
|
@ -29,33 +29,24 @@ func (s *AccountService) GetCount() (int, error) {
|
|||
}
|
||||
|
||||
func (s *AccountService) GetByID(id string) (*model.Account, error) {
|
||||
if account, err := s.repo.GetByID(id); err != nil {
|
||||
return nil, err
|
||||
} else if account == nil {
|
||||
return nil, fmt.Errorf("Account does not exist: %s", id)
|
||||
} else {
|
||||
return account, nil
|
||||
}
|
||||
account, err := s.repo.GetByID(id)
|
||||
if err != nil { return nil, err }
|
||||
if account == nil { return nil, errors.NewNotExistError("Account does not exist") }
|
||||
return account, nil
|
||||
}
|
||||
|
||||
func (s *AccountService) GetByUsername(username string) (*model.Account, error) {
|
||||
if account, err := s.repo.GetByUsername(username); err != nil {
|
||||
return nil, err
|
||||
} else if account == nil {
|
||||
return nil, fmt.Errorf("Account does not exist: %s", username)
|
||||
} else {
|
||||
return account, nil
|
||||
}
|
||||
account, err := s.repo.GetByUsername(username)
|
||||
if err != nil { return nil, err }
|
||||
if account == nil { return nil, errors.NewNotExistError("Account does not exist") }
|
||||
return account, nil
|
||||
}
|
||||
|
||||
func (s *AccountService) GetByEmail(email string) (*model.Account, error) {
|
||||
if account, err := s.repo.GetByEmail(email); err != nil {
|
||||
return nil, err
|
||||
} else if account == nil {
|
||||
return nil, fmt.Errorf("Account does not exist with email: %s", email)
|
||||
} else {
|
||||
return account, nil
|
||||
}
|
||||
account, err := s.repo.GetByEmail(email)
|
||||
if err != nil { return nil, err }
|
||||
if account == nil { return nil, errors.NewNotExistError("Account does not exist") }
|
||||
return account, nil
|
||||
}
|
||||
|
||||
func (s *AccountService) Create(
|
||||
|
|
@ -64,13 +55,13 @@ func (s *AccountService) Create(
|
|||
email *string,
|
||||
avatarURL *string,
|
||||
) (string, error) {
|
||||
if len(username) == 0 { return "", errors.NewValidationError("Username cannot be empty") }
|
||||
if !validator.ValidateID(username) { return "", errors.NewValidationError("Username contains invalid characters") }
|
||||
if len(password) == 0 { return "", errors.NewValidationError("Password cannot be empty") }
|
||||
if email != nil && len(*email) == 0 { return "", errors.NewValidationError("Email cannot be empty") }
|
||||
|
||||
var id string
|
||||
var err error
|
||||
|
||||
if len(username) == 0 { return id, errors.New("Username cannot be empty") }
|
||||
if len(password) == 0 { return id, errors.New("Password cannot be empty") }
|
||||
if email != nil && len(*email) == 0 { return id, errors.New("Email cannot be empty") }
|
||||
|
||||
if id, err = s.repo.Create(username, password, email, avatarURL); err != nil {
|
||||
return id, err
|
||||
}
|
||||
|
|
@ -80,48 +71,31 @@ func (s *AccountService) Create(
|
|||
}
|
||||
|
||||
func (s *AccountService) ChangeUsername(id string, username string) error {
|
||||
if len(username) == 0 { return errors.New("Username cannot be empty") }
|
||||
if err := s.repo.UpdateAvatarURL(id, username); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if len(username) == 0 { return errors.NewValidationError("Username cannot be empty") }
|
||||
if !validator.ValidateID(username) { return errors.NewValidationError("Username contains invalid characters") }
|
||||
if err := s.repo.UpdateUsername(id, username); err != nil { return err }
|
||||
s.log.Printf("Changed username for %s to '%s'", id, username)
|
||||
return nil
|
||||
}
|
||||
func (s *AccountService) ChangePassword(id string, password string) error {
|
||||
if len(password) == 0 { return errors.New("Password cannot be empty") }
|
||||
if err := s.repo.UpdateAvatarURL(id, password); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if len(password) == 0 { return errors.NewValidationError("Password cannot be empty") }
|
||||
if err := s.repo.UpdatePassword(id, password); err != nil { return err }
|
||||
s.log.Printf("Changed password for %s", id)
|
||||
return nil
|
||||
}
|
||||
func (s *AccountService) ChangeEmail(id string, email string) error {
|
||||
if len(email) == 0 { return s.repo.RemoveEmail(id) }
|
||||
if err := s.repo.UpdateAvatarURL(id, email); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.repo.UpdateEmail(id, email); err != nil { return err }
|
||||
s.log.Printf("Changed email for %s to '%s'", id, email)
|
||||
return nil
|
||||
}
|
||||
func (s *AccountService) ChangeAvatarURL(id string, avatarURL string) error {
|
||||
if len(avatarURL) == 0 { return s.repo.RemoveAvatar(id) }
|
||||
if err := s.repo.UpdateAvatarURL(id, avatarURL); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.repo.UpdateAvatarURL(id, avatarURL); err != nil { return err }
|
||||
s.log.Printf("Changed avatar URL for %s to '%s'", id, avatarURL)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *AccountService) Delete(id string) error {
|
||||
if err := s.repo.Delete(id); err != nil { return err }
|
||||
s.log.Printf("Deleted account %s", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *AccountService) IncrementFails(id string) (int, error) {
|
||||
num, err := s.repo.IncrementFails(id)
|
||||
if err != nil { return 0, err }
|
||||
|
|
@ -146,3 +120,11 @@ func (s *AccountService) Unlock(id string) error {
|
|||
s.log.Printf("Unlocked account %s", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *AccountService) Delete(id string) error {
|
||||
deletedID, err := s.repo.Delete(id)
|
||||
if err != nil { return err }
|
||||
if deletedID == "" { return errors.NewNotExistError("Account does not exist") }
|
||||
s.log.Printf("Deleted account %s", id)
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,16 +1,19 @@
|
|||
package account
|
||||
package account_test
|
||||
|
||||
import (
|
||||
"arimelody-web/model"
|
||||
repository "arimelody-web/repository/account"
|
||||
service "arimelody-web/service/account"
|
||||
"arimelody-web/errors"
|
||||
"log"
|
||||
"os"
|
||||
"testing"
|
||||
"gotest.tools/v3/assert"
|
||||
|
||||
"gotest.tools/v3/assert"
|
||||
)
|
||||
|
||||
var (
|
||||
service *AccountService
|
||||
s *service.AccountService
|
||||
)
|
||||
|
||||
func init() {
|
||||
|
|
@ -19,7 +22,7 @@ func init() {
|
|||
defer devNullFile.Close()
|
||||
|
||||
repo := repository.NewAccountRepositoryMemory(make([]*model.Account, 0))
|
||||
service = NewAccountService(
|
||||
s = service.NewAccountService(
|
||||
repo,
|
||||
log.New(devNullFile, "", model.DEFAULT_LOG_FLAGS),
|
||||
)
|
||||
|
|
@ -41,14 +44,14 @@ func Test_Account(t *testing.T) {
|
|||
username := "testificate"
|
||||
password := "the amazing digital data breach"
|
||||
email := "goober@arimelody.space"
|
||||
avatarURL := "/img/default-avatar.webp"
|
||||
avatarURL := "/img/account-avatar.webp"
|
||||
|
||||
var id string
|
||||
var err error
|
||||
|
||||
t.Run("accounts should start empty", func(t *testing.T) {
|
||||
t.Run("count is zero", func(t *testing.T) {
|
||||
if num, err := service.GetCount(); err != nil {
|
||||
if num, err := s.GetCount(); err != nil {
|
||||
t.Errorf("Failed to get number of accounts: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 0)
|
||||
|
|
@ -56,8 +59,8 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("service returns empty array", func(t *testing.T) {
|
||||
if accounts, err := service.GetAll(); err != nil {
|
||||
t.Errorf("Failed to get number of accounts: %v", err)
|
||||
if accounts, err := s.GetAll(); err != nil {
|
||||
t.Errorf("Failed to get accounts: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(accounts), 0)
|
||||
}
|
||||
|
|
@ -65,13 +68,28 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can create account", func(t *testing.T) {
|
||||
id, err = service.Create(username, password, &email, &avatarURL)
|
||||
id, err = s.Create(username, password, &email, &avatarURL)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to create account: %v", err)
|
||||
}
|
||||
|
||||
t.Run("but not with invalid username", func(t *testing.T) {
|
||||
if _, err := s.Create("", password, &email, &avatarURL); err == nil {
|
||||
t.Error("Could create account with invalid username")
|
||||
} else if !errors.IsValidationError(err) {
|
||||
t.Error("Error is not validation error")
|
||||
}
|
||||
})
|
||||
t.Run("but not with invalid password", func(t *testing.T) {
|
||||
if _, err := s.Create("test-username", "", &email, &avatarURL); err == nil {
|
||||
t.Error("Could create account with invalid password")
|
||||
} else if !errors.IsValidationError(err) {
|
||||
t.Error("Error is not validation error")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("and fetch by ID", func(t *testing.T) {
|
||||
account, err := service.GetByID(id)
|
||||
account, err := s.GetByID(id)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to get account after creation: %v", err)
|
||||
}
|
||||
|
|
@ -84,7 +102,7 @@ func Test_Account(t *testing.T) {
|
|||
assert.Equal(t, account.Locked, false)
|
||||
})
|
||||
t.Run("and fetch by username", func(t *testing.T) {
|
||||
account, err := service.GetByUsername(username)
|
||||
account, err := s.GetByUsername(username)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to get account after creation: %v", err)
|
||||
}
|
||||
|
|
@ -97,7 +115,7 @@ func Test_Account(t *testing.T) {
|
|||
assert.Equal(t, account.Locked, false)
|
||||
})
|
||||
t.Run("and fetch by email", func(t *testing.T) {
|
||||
account, err := service.GetByEmail(email)
|
||||
account, err := s.GetByEmail(email)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to get account after creation: %v", err)
|
||||
}
|
||||
|
|
@ -113,7 +131,7 @@ func Test_Account(t *testing.T) {
|
|||
|
||||
t.Run("number of accounts should increment", func(t *testing.T) {
|
||||
t.Run("count is one", func(t *testing.T) {
|
||||
if num, err := service.GetCount(); err != nil {
|
||||
if num, err := s.GetCount(); err != nil {
|
||||
t.Errorf("Failed to get number of accounts: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 1)
|
||||
|
|
@ -121,8 +139,8 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("service returns array with one account", func(t *testing.T) {
|
||||
if accounts, err := service.GetAll(); err != nil {
|
||||
t.Errorf("Failed to get number of accounts: %v", err)
|
||||
if accounts, err := s.GetAll(); err != nil {
|
||||
t.Errorf("Failed to get accounts: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, len(accounts), 1)
|
||||
}
|
||||
|
|
@ -130,7 +148,7 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can't create duplicate account", func(t *testing.T) {
|
||||
_, err := service.Create(username, password, &email, &avatarURL)
|
||||
_, err := s.Create(username, password, &email, &avatarURL)
|
||||
if err == nil {
|
||||
t.Error("Duplicate account was created")
|
||||
}
|
||||
|
|
@ -138,11 +156,11 @@ func Test_Account(t *testing.T) {
|
|||
|
||||
t.Run("can change username", func(t *testing.T) {
|
||||
testUsername := "some_other_name"
|
||||
if err := service.ChangeUsername(id, testUsername); err != nil {
|
||||
if err := s.ChangeUsername(id, testUsername); err != nil {
|
||||
t.Errorf("Failed to change username: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -151,19 +169,21 @@ func Test_Account(t *testing.T) {
|
|||
}
|
||||
|
||||
t.Run("but not to an invalid value", func(t *testing.T) {
|
||||
if err := service.ChangeUsername(id, ""); err == nil {
|
||||
if err := s.ChangeUsername(id, ""); err == nil {
|
||||
t.Error("Could change username to invalid value")
|
||||
} else if !errors.IsValidationError(err) {
|
||||
t.Error("Error is not validation error")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can change password", func(t *testing.T) {
|
||||
testPassword := "other more different password"
|
||||
if err := service.ChangePassword(id, testPassword); err != nil {
|
||||
if err := s.ChangePassword(id, testPassword); err != nil {
|
||||
t.Errorf("Failed to change password: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -172,19 +192,21 @@ func Test_Account(t *testing.T) {
|
|||
}
|
||||
|
||||
t.Run("but not to an invalid value", func(t *testing.T) {
|
||||
if err := service.ChangePassword(id, ""); err == nil {
|
||||
if err := s.ChangePassword(id, ""); err == nil {
|
||||
t.Error("Could change password to invalid value")
|
||||
} else if !errors.IsValidationError(err) {
|
||||
t.Error("Error is not validation error")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can change email", func(t *testing.T) {
|
||||
testEmail := "brandnewemail@for.me"
|
||||
if err := service.ChangeEmail(id, testEmail); err != nil {
|
||||
if err := s.ChangeEmail(id, testEmail); err != nil {
|
||||
t.Errorf("Failed to change email: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -194,11 +216,11 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can remove email", func(t *testing.T) {
|
||||
if err := service.ChangeEmail(id, ""); err != nil {
|
||||
if err := s.ChangeEmail(id, ""); err != nil {
|
||||
t.Errorf("Failed to change email: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -209,11 +231,11 @@ func Test_Account(t *testing.T) {
|
|||
|
||||
t.Run("can change avatar URL", func(t *testing.T) {
|
||||
testAvatarURL := "/img/some-other-avatar.webp"
|
||||
if err := service.ChangeAvatarURL(id, testAvatarURL); err != nil {
|
||||
if err := s.ChangeAvatarURL(id, testAvatarURL); err != nil {
|
||||
t.Errorf("Failed to change avatar URL: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -223,11 +245,11 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can remove avatar URL", func(t *testing.T) {
|
||||
if err := service.ChangeAvatarURL(id, ""); err != nil {
|
||||
if err := s.ChangeAvatarURL(id, ""); err != nil {
|
||||
t.Errorf("Failed to change avatar URL: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -237,13 +259,13 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can increment auth failures", func(t *testing.T) {
|
||||
if num, err := service.IncrementFails(id); err != nil {
|
||||
if num, err := s.IncrementFails(id); err != nil {
|
||||
t.Errorf("Failed to increment account auth failures: %v", err)
|
||||
} else {
|
||||
assert.Equal(t, num, 1)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -253,11 +275,11 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can reset auth failures", func(t *testing.T) {
|
||||
if err := service.ResetFails(id); err != nil {
|
||||
if err := s.ResetFails(id); err != nil {
|
||||
t.Errorf("Failed to reset account auth failures: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -267,11 +289,11 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can lock account", func(t *testing.T) {
|
||||
if err := service.Lock(id); err != nil {
|
||||
if err := s.Lock(id); err != nil {
|
||||
t.Errorf("Failed to lock account: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -281,11 +303,11 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can unlock account", func(t *testing.T) {
|
||||
if err := service.Unlock(id); err != nil {
|
||||
if err := s.Unlock(id); err != nil {
|
||||
t.Errorf("Failed to unlock account: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account: %v", err)
|
||||
} else if account == nil {
|
||||
t.Error("Account is nil after update")
|
||||
|
|
@ -295,12 +317,14 @@ func Test_Account(t *testing.T) {
|
|||
})
|
||||
|
||||
t.Run("can delete account", func(t *testing.T) {
|
||||
if err = service.Delete(id); err != nil {
|
||||
if err = s.Delete(id); err != nil {
|
||||
t.Errorf("Failed to delete account: %v", err)
|
||||
}
|
||||
|
||||
if account, err := service.GetByID(id); err != nil {
|
||||
t.Errorf("Failed to get account after deletion: %v", err)
|
||||
if account, err := s.GetByID(id); err != nil {
|
||||
if !errors.IsNotExistError(err) {
|
||||
t.Errorf("Failed to get account after deletion: %v", err)
|
||||
}
|
||||
} else if account != nil {
|
||||
t.Error("Account still exists after deletion")
|
||||
}
|
||||
|
|
@ -308,56 +332,76 @@ func Test_Account(t *testing.T) {
|
|||
|
||||
t.Run("can't create an account with invalid", func(t *testing.T) {
|
||||
t.Run("username", func(t *testing.T) {
|
||||
if _, err := service.Create("", password, &email, &avatarURL); err == nil {
|
||||
if _, err := s.Create("", password, &email, &avatarURL); err == nil {
|
||||
t.Error("Could create account with empty username")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("password", func(t *testing.T) {
|
||||
if _, err := service.Create(username, "", &email, &avatarURL); err == nil {
|
||||
if _, err := s.Create(username, "", &email, &avatarURL); err == nil {
|
||||
t.Error("Could create account with empty password")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("email", func(t *testing.T) {
|
||||
testEmail := ""
|
||||
if _, err := service.Create(username, password, &testEmail, &avatarURL); err == nil {
|
||||
if _, err := s.Create(username, password, &testEmail, &avatarURL); err == nil {
|
||||
t.Error("Could create account with empty (non-nil) email")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can't fetch account that doesn't exist", func(t *testing.T) {
|
||||
t.Run("by ID", func(t *testing.T) {
|
||||
if account, err := s.GetByID("adsginh534g9405gmb40i9bm"); err != nil {
|
||||
if !errors.IsNotExistError(err) { t.Errorf("Failed to get account: %v", err) }
|
||||
} else if account != nil {
|
||||
t.Error("Could fetch non-existent account")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("by username", func(t *testing.T) {
|
||||
if account, err := s.GetByUsername("adsginh534g9405gmb40i9bm"); err != nil {
|
||||
if !errors.IsNotExistError(err) { t.Errorf("Failed to get account: %v", err) }
|
||||
} else if account != nil {
|
||||
t.Error("Could fetch non-existent account")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("email", func(t *testing.T) {
|
||||
if account, err := s.GetByEmail("adsginh534g9405gmb40i9bm"); err != nil {
|
||||
if !errors.IsNotExistError(err) { t.Errorf("Failed to get account: %v", err) }
|
||||
} else if account != nil {
|
||||
t.Error("Could fetch non-existent account")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("can't update account that doesn't exist", func(t *testing.T) {
|
||||
garbageAccountID := "adsginh534g9405gmb40i9bm"
|
||||
|
||||
t.Run("username", func(t *testing.T) {
|
||||
if err := service.ChangeUsername(garbageAccountID, "some-username"); err == nil {
|
||||
if err := s.ChangeUsername(garbageAccountID, "some-username"); err == nil {
|
||||
t.Error("Could update non-existent account's username")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("password", func(t *testing.T) {
|
||||
if err := service.ChangePassword(garbageAccountID, "some-password"); err == nil {
|
||||
if err := s.ChangePassword(garbageAccountID, "some-password"); err == nil {
|
||||
t.Error("Could update non-existent account's password")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("email", func(t *testing.T) {
|
||||
if err := service.ChangeEmail(garbageAccountID, "some-email@real.gov"); err == nil {
|
||||
if err := s.ChangeEmail(garbageAccountID, "some-email@real.gov"); err == nil {
|
||||
t.Error("Could update non-existent account's email")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("avatar URL", func(t *testing.T) {
|
||||
if err := service.ChangeAvatarURL(garbageAccountID, "/img/null.webp"); err == nil {
|
||||
if err := s.ChangeAvatarURL(garbageAccountID, "/img/null.webp"); err == nil {
|
||||
t.Error("Could update non-existent account's avatar URL")
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
t.Cleanup(func() {
|
||||
if err := service.Delete(id); err != nil {
|
||||
t.Errorf("Failed to clean up test case: %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package log
|
|||
import (
|
||||
"arimelody-web/model"
|
||||
repository "arimelody-web/repository/log"
|
||||
"arimelody-web/errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"time"
|
||||
|
|
@ -43,7 +44,10 @@ func (s *LogService) Warn(logType string, format string, args ...any) {
|
|||
}
|
||||
|
||||
func (s *LogService) Fetch(id string) (*model.Log, error) {
|
||||
return s.repo.Get(id)
|
||||
log, err := s.repo.Get(id)
|
||||
if err != nil { return nil, err }
|
||||
if log == nil { return nil, errors.NewNotExistError("Log does not exist") }
|
||||
return log, nil
|
||||
}
|
||||
|
||||
func (s *LogService) Search(
|
||||
|
|
|
|||
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
|
||||
}
|
||||
8
service/validator/validator.go
Normal file
8
service/validator/validator.go
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
package validator
|
||||
|
||||
import "regexp"
|
||||
|
||||
var idRegexp = regexp.MustCompile(`^[a-zA-Z0-9\-_\.]+$`)
|
||||
func ValidateID(id string) bool {
|
||||
return idRegexp.MatchString(id)
|
||||
}
|
||||
39
service/validator/validator_test.go
Normal file
39
service/validator/validator_test.go
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
package validator_test
|
||||
|
||||
import (
|
||||
"arimelody-web/service/validator"
|
||||
"testing"
|
||||
|
||||
"gotest.tools/v3/assert"
|
||||
)
|
||||
|
||||
func Test_ValidateID(t *testing.T) {
|
||||
t.Run("accepts alphanumberic ID", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("abcDEF123"), true)
|
||||
})
|
||||
|
||||
t.Run("accepts hyphens", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("a0-1b"), true)
|
||||
})
|
||||
t.Run("accepts underscores", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("a0_1b"), true)
|
||||
})
|
||||
t.Run("accepts periods", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("a0.1b"), true)
|
||||
})
|
||||
|
||||
t.Run("rejects other characters", func(t *testing.T) {
|
||||
t.Run("emoji", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("🗣️🔥‼️"), false)
|
||||
})
|
||||
t.Run("slashes", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("this/could/be/really/bad/for/the/router"), false)
|
||||
})
|
||||
t.Run("question marks", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("query?these=nuts"), false)
|
||||
})
|
||||
t.Run("hashes", func(t *testing.T) {
|
||||
assert.Equal(t, validator.ValidateID("unnecessary#tagging"), false)
|
||||
})
|
||||
})
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue