rogee/gochat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
gochat/backend/internal/service/coverage4_test.go
T
Rogeeandrogee 2b182f9956 H-300: wire Captain Skills into Web runtime (#48) 
* H-300: wire Captain Skills into Web runtime

* H-300: enforce effective model and conservative skill budget

* H-300: fix CI gosec step

* ci: extend golangci-lint timeout

* fix lint findings across backend

* fix(push): resolve delivery protocol blockers

* test(repository): close SQLite test databases

* test(repository): reuse SQLite schema per package

* H-307: restore backend Go cache in CI

* H-307: prefetch modules before cold lint

* H-307: resolve govulncheck security gate

* H-307: build lint with patched Go toolchain

* H-307: clear remaining security scan findings

---------

Co-authored-by: Rogee <rogee@ipao.vip>
2026-08-19 07:08:14 +08:00

784 lines
25 KiB
Go
Raw Permalink Blame History

package service
import (
"context"
"testing"
"github.com/gochat/gochat/internal/config"
"github.com/gochat/gochat/internal/model"
"github.com/gochat/gochat/internal/repository"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
)
// ============================================================
// AccountService tests
// ============================================================
func newAccountServiceDB(t *testing.T) *gorm.DB {
return newSimpleServiceTestDB(t)
}
func TestAccountService_GetByID(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
acc := &model.Account{Name: "TestAcc"}
require.NoError(t, db.Create(acc).Error)
got, err := svc.GetByID(context.Background(), acc.ID)
require.NoError(t, err)
assert.Equal(t, "TestAcc", got.Name)
}
func TestAccountService_GetByID_NotFound(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
_, err := svc.GetByID(context.Background(), 99999)
require.Error(t, err)
}
func TestAccountService_ListByUser(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
require.NoError(t, db.Create(&model.Account{Name: "A1"}).Error)
require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)
list, total, err := svc.ListByUser(context.Background(), 1, 0, 10)
require.NoError(t, err)
assert.GreaterOrEqual(t, total, int64(1))
assert.GreaterOrEqual(t, len(list), 1)
}
func TestAccountService_Create(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)
acc, err := svc.Create(context.Background(), 1, CreateAccountRequest{Name: "NewAcc"})
require.NoError(t, err)
assert.Equal(t, "NewAcc", acc.Name)
assert.NotZero(t, acc.ID)
}
func TestAccountService_Update(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
acc := &model.Account{Name: "Orig"}
require.NoError(t, db.Create(acc).Error)
updated, err := svc.Update(context.Background(), acc.ID, UpdateAccountRequest{Name: "Updated"})
require.NoError(t, err)
assert.Equal(t, "Updated", updated.Name)
}
func TestAccountService_Delete(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
acc := &model.Account{Name: "Del"}
require.NoError(t, db.Create(acc).Error)
require.NoError(t, svc.Delete(context.Background(), acc.ID))
}
func TestAccountService_UpdateOnboarding(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
acc := &model.Account{Name: "OB"}
require.NoError(t, db.Create(acc).Error)
name := "Updated"
updated, err := svc.UpdateOnboarding(context.Background(), acc.ID, UpdateAccountOnboardingRequest{
Name: &name,
})
require.NoError(t, err)
assert.Equal(t, "Updated", updated.Name)
}
func TestAccountService_UpdateSettings(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
acc := &model.Account{Name: "S"}
require.NoError(t, db.Create(acc).Error)
updated, err := svc.UpdateSettings(context.Background(), acc.ID, UpdateAccountSettingsRequest{
AutoResolveDuration: 10,
Locale: "en",
})
require.NoError(t, err)
assert.NotNil(t, updated)
}
func TestAccountService_DB(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
assert.NotNil(t, svc.DB())
}
func TestAccountService_GetByUserAndID(t *testing.T) {
db := newAccountServiceDB(t)
repo := repository.NewAccountRepo(db)
svc := NewAccountService(repo)
require.NoError(t, db.Create(&model.Account{Name: "A"}).Error)
require.NoError(t, db.Create(&model.User{Name: "U", Email: "u@e.com", Password: "x", Role: "admin", Active: true}).Error)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)
acc, err := svc.GetByUserAndID(context.Background(), 1, 1)
require.NoError(t, err)
assert.Equal(t, "A", acc.Name)
}
// ============================================================
// ContactService tests
// ============================================================
func newContactServiceDB(t *testing.T) *gorm.DB {
return newSimpleServiceTestDB(t)
}
func TestContactService_GetByID(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
c := &model.Contact{AccountID: 1, Name: "C1"}
require.NoError(t, db.Create(c).Error)
got, err := svc.GetByID(context.Background(), c.ID)
require.NoError(t, err)
assert.Equal(t, "C1", got.Name)
}
func TestContactService_GetByID_NotFound(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
_, err := svc.GetByID(context.Background(), 99999)
require.Error(t, err)
}
func TestContactService_GetByAccountAndID(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
c := &model.Contact{AccountID: 1, Name: "C1"}
require.NoError(t, db.Create(c).Error)
got, err := svc.GetByAccountAndID(context.Background(), 1, c.ID)
require.NoError(t, err)
assert.Equal(t, "C1", got.Name)
}
func TestContactService_ListByAccount(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
require.NoError(t, db.Create(&model.Contact{AccountID: 1, Name: "C1", Email: "c1@test.com"}).Error)
require.NoError(t, db.Create(&model.Contact{AccountID: 1, Name: "C2", Email: "c2@test.com"}).Error)
list, total, err := svc.ListByAccount(context.Background(), 1, 0, 10, "")
require.NoError(t, err)
assert.Equal(t, int64(2), total)
assert.Len(t, list, 2)
}
func TestContactService_Create(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
created, err := svc.Create(context.Background(), 1, CreateContactRequest{
Name: "NewContact",
})
require.NoError(t, err)
assert.Equal(t, "NewContact", created.Name)
assert.NotZero(t, created.ID)
}
func TestContactService_ListContactInboxes(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
c := &model.Contact{AccountID: 1, Name: "C"}
require.NoError(t, db.Create(c).Error)
require.NoError(t, db.Create(&model.ContactInbox{ContactID: c.ID, InboxID: 1, SourceID: "src1"}).Error)
inboxes, err := svc.ListContactInboxes(context.Background(), c.ID)
require.NoError(t, err)
assert.Len(t, inboxes, 1)
}
func TestContactService_DB(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
assert.NotNil(t, svc.DB())
}
func TestContactService_Ready(t *testing.T) {
db := newContactServiceDB(t)
contactRepo := repository.NewContactRepo(db)
contactInboxRepo := repository.NewContactInboxRepo(db)
noteRepo := repository.NewNoteRepo(db)
contactInboxSvc := NewContactInboxService(contactInboxRepo)
svc := NewContactService(contactRepo, contactInboxSvc, noteRepo)
assert.True(t, svc.Ready())
}
// ============================================================
// ArticleService tests
// ============================================================
func newArticleServiceDB(t *testing.T) *gorm.DB {
db := newSimpleServiceTestDB(t)
if err := db.AutoMigrate(&model.Article{}); err != nil {
panic(err)
}
return db
}
func TestArticleService_Create(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
article, err := svc.Create(context.Background(), 1, 1, &CreateArticleRequest{
Title: "Test Article",
Content: "Content here",
Status: model.ArticleStatus("published"),
})
require.NoError(t, err)
assert.Equal(t, "Test Article", article.Title)
}
func TestArticleService_GetByID(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A", Content: "C", Status: "draft"}
require.NoError(t, db.Create(a).Error)
got, err := svc.GetByID(context.Background(), a.ID)
require.NoError(t, err)
assert.Equal(t, "A", got.Title)
}
func TestArticleService_GetByID_NotFound(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
_, err := svc.GetByID(context.Background(), 99999)
require.Error(t, err)
}
func TestArticleService_GetByPortalAndID(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A", Content: "C", Status: "draft"}
require.NoError(t, db.Create(a).Error)
got, err := svc.GetByPortalAndID(context.Background(), 1, a.ID)
require.NoError(t, err)
assert.Equal(t, "A", got.Title)
}
func TestArticleService_Update(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Orig", Content: "C", Status: "draft"}
require.NoError(t, db.Create(a).Error)
newTitle := "Updated"
newContent := "New content"
updated, err := svc.Update(context.Background(), a.ID, &UpdateArticleRequest{
Title: &newTitle,
Content: &newContent,
})
require.NoError(t, err)
assert.Equal(t, "Updated", updated.Title)
}
func TestArticleService_Delete(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Del", Content: "C", Status: "draft"}
require.NoError(t, db.Create(a).Error)
require.NoError(t, svc.Delete(context.Background(), a.ID))
}
func TestArticleService_DeleteScoped(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
a := &model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "Del", Content: "C", Status: "draft"}
require.NoError(t, db.Create(a).Error)
require.NoError(t, svc.DeleteScoped(context.Background(), 1, a.ID))
}
func TestArticleService_ListByPortalID(t *testing.T) {
db := newArticleServiceDB(t)
repo := repository.NewArticleRepo(db)
svc := NewArticleService(repo)
require.NoError(t, db.Create(&model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A1", Slug: "a1", Content: "C", Status: "published"}).Error)
require.NoError(t, db.Create(&model.Article{PortalID: 1, AuthorID: uintPtr(1), Title: "A2", Slug: "a2", Content: "C", Status: "draft"}).Error)
list, total, err := svc.ListByPortalID(context.Background(), 1, 1, 10)
require.NoError(t, err)
assert.Equal(t, int64(2), total)
assert.Len(t, list, 2)
}
// ============================================================
// RBACService tests
// ============================================================
func newRBACServiceDB(t *testing.T) *gorm.DB {
db := newSimpleServiceTestDB(t)
if err := db.AutoMigrate(&model.CustomRole{}, &model.PlatformApp{}, &model.AccessToken{}); err != nil {
panic(err)
}
return db
}
func TestRBACService_GetAccountUser(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
au, err := svc.GetAccountUser(1, 1)
require.NoError(t, err)
assert.Equal(t, "agent", au.Role)
}
func TestRBACService_GetAccountUser_NotFound(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
_, err := svc.GetAccountUser(999, 999)
require.Error(t, err)
}
func TestRBACService_AddAccountUser(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
au, err := svc.AddAccountUser(1, 1, "agent", 0, 1)
require.NoError(t, err)
assert.Equal(t, "agent", au.Role)
}
func TestRBACService_UpdateAccountUserRole(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
au, err := svc.UpdateAccountUserRole(1, 1, "administrator", 0)
require.NoError(t, err)
assert.Equal(t, "administrator", au.Role)
}
func TestRBACService_RemoveAccountUser(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
require.NoError(t, svc.RemoveAccountUser(1, 1))
}
func TestRBACService_ListAccountUsers(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
require.NoError(t, db.Create(&model.AccountUser{UserID: 2, AccountID: 1, Role: "admin"}).Error)
users, err := svc.ListAccountUsers(1)
require.NoError(t, err)
assert.Len(t, users, 2)
}
func TestRBACService_ListUserAccounts(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 2, Role: "admin"}).Error)
accounts, err := svc.ListUserAccounts(1)
require.NoError(t, err)
assert.Len(t, accounts, 2)
}
func TestRBACService_UpdateAvailability(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "agent"}).Error)
require.NoError(t, svc.UpdateAvailability(1, 1, "online"))
}
func TestRBACService_CreateCustomRole(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
role, err := svc.CreateCustomRole(1, "CustomRole", nil, "Test role")
require.NoError(t, err)
assert.Equal(t, "CustomRole", role.Name)
}
func TestRBACService_GetCustomRole(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
r := &model.CustomRole{AccountID: 1, Name: "CR", Description: "desc"}
require.NoError(t, db.Create(r).Error)
got, err := svc.GetCustomRole(r.ID)
require.NoError(t, err)
assert.Equal(t, "CR", got.Name)
}
func TestRBACService_ListCustomRoles(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.CustomRole{AccountID: 1, Name: "R1"}).Error)
require.NoError(t, db.Create(&model.CustomRole{AccountID: 1, Name: "R2"}).Error)
roles, err := svc.ListCustomRoles(1)
require.NoError(t, err)
assert.Len(t, roles, 2)
}
func TestRBACService_UpdateCustomRole(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
r := &model.CustomRole{AccountID: 1, Name: "Orig", Description: "d"}
require.NoError(t, db.Create(r).Error)
updated, err := svc.UpdateCustomRole(r.ID, "Updated", nil, "new desc")
require.NoError(t, err)
assert.Equal(t, "Updated", updated.Name)
}
func TestRBACService_DeleteCustomRole(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
r := &model.CustomRole{AccountID: 1, Name: "Del"}
require.NoError(t, db.Create(r).Error)
require.NoError(t, svc.DeleteCustomRole(r.ID))
}
func TestRBACService_BuildPolicyContext(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)
ctx, err := svc.BuildPolicyContext(1, 1)
require.NoError(t, err)
assert.NotNil(t, ctx)
}
func TestRBACService_CanPerform(t *testing.T) {
db := newRBACServiceDB(t)
svc := NewRBACService(db)
require.NoError(t, db.Create(&model.AccountUser{UserID: 1, AccountID: 1, Role: "admin"}).Error)
can, err := svc.CanPerform(1, 1, "read", "conversation")
require.NoError(t, err)
_ = can
}
// ============================================================
// PlatformAppService tests
// ============================================================
func newPlatformAppServiceDB(t *testing.T) *gorm.DB {
db := newSimpleServiceTestDB(t)
if err := db.AutoMigrate(&model.PlatformApp{}, &model.AccessToken{}, &model.Permissible{}); err != nil {
panic(err)
}
return db
}
func TestPlatformAppService_Create(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, token, err := svc.Create(context.Background(), CreatePlatformAppRequest{
Name: "TestApp",
AccountID: 1,
Type: "api",
Description: "Test app",
})
require.NoError(t, err)
assert.Equal(t, "TestApp", app.Name)
assert.NotEmpty(t, token)
}
func TestPlatformAppService_GetByID(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
got, err := svc.GetByID(context.Background(), app.ID)
require.NoError(t, err)
assert.Equal(t, "App", got.Name)
}
func TestPlatformAppService_GetByID_NotFound(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
_, err := svc.GetByID(context.Background(), 99999)
require.Error(t, err)
}
func TestPlatformAppService_ListAll(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A1", AccountID: 1, Type: "api"})
require.NoError(t, err)
_, _, err = svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A2", AccountID: 1, Type: "api"})
require.NoError(t, err)
apps, total, err := svc.ListAll(context.Background(), 0, 10)
require.NoError(t, err)
assert.Equal(t, int64(2), total)
assert.Len(t, apps, 2)
}
func TestPlatformAppService_ListByAccount(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "A1", AccountID: 1, Type: "api"})
require.NoError(t, err)
apps, total, err := svc.ListByAccount(context.Background(), 1, 0, 10)
require.NoError(t, err)
assert.Equal(t, int64(1), total)
assert.Len(t, apps, 1)
}
func TestPlatformAppService_Search(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
_, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Searchable", AccountID: 1, Type: "api"})
require.NoError(t, err)
apps, total, err := svc.Search(context.Background(), "Search", 0, 10)
require.NoError(t, err)
assert.Equal(t, int64(1), total)
assert.Len(t, apps, 1)
}
func TestPlatformAppService_Update(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Orig", AccountID: 1, Type: "api"})
require.NoError(t, err)
updated, err := svc.Update(context.Background(), app.ID, UpdatePlatformAppRequest{
Name: "Updated",
Description: "New desc",
Type: "api",
})
require.NoError(t, err)
assert.Equal(t, "Updated", updated.Name)
}
func TestPlatformAppService_Delete(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "Del", AccountID: 1, Type: "api"})
require.NoError(t, err)
require.NoError(t, svc.Delete(context.Background(), app.ID))
}
func TestPlatformAppService_RegenerateAccessToken(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
newToken, err := svc.RegenerateAccessToken(context.Background(), app.ID)
require.NoError(t, err)
assert.NotEmpty(t, newToken)
}
func TestPlatformAppService_ListAccessTokens(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
tokens, err := svc.ListAccessTokens(context.Background(), app.ID)
require.NoError(t, err)
assert.Len(t, tokens, 1)
}
func TestPlatformAppService_AddPermissible(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
perm, err := svc.AddPermissible(context.Background(), app.ID, "Account", 1)
require.NoError(t, err)
assert.NotZero(t, perm.ID)
}
func TestPlatformAppService_ListPermissibles(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
_, err = svc.AddPermissible(context.Background(), app.ID, "Account", 1)
require.NoError(t, err)
perms, err := svc.ListPermissibles(context.Background(), app.ID)
require.NoError(t, err)
assert.Len(t, perms, 1)
}
func TestPlatformAppService_RemovePermissible(t *testing.T) {
db := newPlatformAppServiceDB(t)
repo := repository.NewPlatformAppRepo(db)
tokenRepo := repository.NewAccessTokenRepo(db)
permRepo := repository.NewPermissibleRepo(db)
svc := NewPlatformAppService(repo, tokenRepo, permRepo)
app, _, err := svc.Create(context.Background(), CreatePlatformAppRequest{Name: "App", AccountID: 1, Type: "api"})
require.NoError(t, err)
_, err = svc.AddPermissible(context.Background(), app.ID, "Account", 1)
require.NoError(t, err)
require.NoError(t, svc.RemovePermissible(context.Background(), app.ID, "Account", 1))
}
// ============================================================
// UploadService tests (minimal - needs config)
// ============================================================
func TestUploadService_UploadDir(t *testing.T) {
db := newSimpleServiceTestDB(t)
cfg := &config.Config{}
repo := repository.NewDirectUploadRepo(db)
svc := NewUploadService(repo, cfg)
assert.NotNil(t, svc)
}
Reference in New Issue View Git Blame Copy Permalink