312 lines
14 KiB
Go
312 lines
14 KiB
Go
package v1
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/gochat/gochat/internal/llm"
|
|
"github.com/gochat/gochat/internal/model"
|
|
"github.com/gochat/gochat/internal/repository"
|
|
"github.com/gochat/gochat/internal/service"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func setupCaptainAssistantHandlerTest(t *testing.T) (*gin.Engine, *gorm.DB) {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
dbName := fmt.Sprintf("file:%s?mode=memory&cache=private", t.Name())
|
|
db, err := gorm.Open(sqlite.Open(dbName), &gorm.Config{})
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.AutoMigrate(
|
|
&model.Account{},
|
|
&model.Inbox{},
|
|
&model.CaptainAssistant{},
|
|
&model.CaptainInbox{},
|
|
))
|
|
t.Cleanup(func() {
|
|
sqlDB, _ := db.DB()
|
|
sqlDB.Close()
|
|
})
|
|
|
|
assistantRepo := repository.NewCaptainAssistantRepo(db)
|
|
inboxRepo := repository.NewCaptainInboxRepo(db)
|
|
documentRepo := repository.NewCaptainDocumentRepo(db)
|
|
responseRepo := repository.NewCaptainAssistantResponseRepo(db)
|
|
svc := service.NewCaptainAssistantService(assistantRepo, inboxRepo, documentRepo, responseRepo, nil)
|
|
handler := NewCaptainAssistantHandler(svc)
|
|
|
|
router := gin.New()
|
|
assistants := router.Group("/api/v1/accounts/:account_id/captain/assistants")
|
|
assistants.GET("/", handler.List)
|
|
assistants.POST("/", handler.Create)
|
|
assistants.GET("/tools", handler.Tools)
|
|
assistants.GET("/:assistant_id", handler.Get)
|
|
assistants.PUT("/:assistant_id", handler.Update)
|
|
assistants.DELETE("/:assistant_id", handler.Delete)
|
|
assistants.POST("/:assistant_id/playground", handler.GenerateResponse)
|
|
assistants.GET("/:assistant_id/inboxes", handler.ListInboxes)
|
|
assistants.POST("/:assistant_id/inboxes", handler.AssociateInbox)
|
|
assistants.DELETE("/:assistant_id/inboxes/:inbox_id", handler.DissociateInbox)
|
|
return router, db
|
|
}
|
|
|
|
func setupCaptainAssistantHandlerTestWithProvider(t *testing.T, provider llm.Provider) (*gin.Engine, *gorm.DB) {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
dbName := fmt.Sprintf("file:%s-provider?mode=memory&cache=private", t.Name())
|
|
db, err := gorm.Open(sqlite.Open(dbName), &gorm.Config{})
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.AutoMigrate(
|
|
&model.Account{},
|
|
&model.Inbox{},
|
|
&model.CaptainAssistant{},
|
|
&model.CaptainInbox{},
|
|
))
|
|
t.Cleanup(func() {
|
|
sqlDB, _ := db.DB()
|
|
sqlDB.Close()
|
|
})
|
|
|
|
assistantRepo := repository.NewCaptainAssistantRepo(db)
|
|
inboxRepo := repository.NewCaptainInboxRepo(db)
|
|
documentRepo := repository.NewCaptainDocumentRepo(db)
|
|
responseRepo := repository.NewCaptainAssistantResponseRepo(db)
|
|
svc := service.NewCaptainAssistantService(assistantRepo, inboxRepo, documentRepo, responseRepo, provider)
|
|
handler := NewCaptainAssistantHandler(svc)
|
|
|
|
router := gin.New()
|
|
assistants := router.Group("/api/v1/accounts/:account_id/captain/assistants")
|
|
assistants.POST("/:assistant_id/playground", handler.GenerateResponse)
|
|
return router, db
|
|
}
|
|
|
|
func seedCaptainAssistantAccount(t *testing.T, db *gorm.DB, name string) *model.Account {
|
|
t.Helper()
|
|
account := &model.Account{Name: name, Locale: "en", Active: true}
|
|
require.NoError(t, db.Create(account).Error)
|
|
return account
|
|
}
|
|
|
|
func captainAssistantJSONRequest(t *testing.T, router *gin.Engine, method, path string, body any) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
var reader *bytes.Reader
|
|
if body == nil {
|
|
reader = bytes.NewReader(nil)
|
|
} else {
|
|
payload, err := json.Marshal(body)
|
|
require.NoError(t, err)
|
|
reader = bytes.NewReader(payload)
|
|
}
|
|
w := httptest.NewRecorder()
|
|
req := httptest.NewRequest(method, path, reader)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
router.ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_CRUDUsesChatwootPayloadShape(t *testing.T) {
|
|
router, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Org")
|
|
basePath := "/api/v1/accounts/" + strconv.FormatUint(uint64(account.ID), 10) + "/captain/assistants"
|
|
|
|
createBody := map[string]any{
|
|
"assistant": map[string]any{
|
|
"name": "Fin",
|
|
"description": "Support copilot",
|
|
"config": map[string]any{
|
|
"product_name": "GoChat",
|
|
"temperature": 0.2,
|
|
},
|
|
"guardrails": []string{"never ask for passwords"},
|
|
"response_guidelines": []string{"be concise"},
|
|
},
|
|
}
|
|
w := captainAssistantJSONRequest(t, router, http.MethodPost, basePath+"/", createBody)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var created map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &created))
|
|
assert.NotContains(t, created, "success")
|
|
assert.NotContains(t, created, "data")
|
|
assert.Equal(t, float64(account.ID), created["account_id"])
|
|
assert.Equal(t, "Fin", created["name"])
|
|
assert.Equal(t, "Support copilot", created["description"])
|
|
assert.Equal(t, "GoChat", created["config"].(map[string]any)["product_name"])
|
|
assistantID := uint(created["id"].(float64))
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, basePath+"/", nil)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var listResp map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &listResp))
|
|
assert.Len(t, listResp["payload"], 1)
|
|
assert.Equal(t, float64(1), listResp["meta"].(map[string]any)["total_count"])
|
|
assert.Equal(t, float64(1), listResp["meta"].(map[string]any)["page"])
|
|
|
|
updateBody := map[string]any{"assistant": map[string]any{"name": "Fin Prime", "description": "Updated"}}
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPut, fmt.Sprintf("%s/%d", basePath, assistantID), updateBody)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var updated map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &updated))
|
|
assert.Equal(t, "Fin Prime", updated["name"])
|
|
assert.Equal(t, "Updated", updated["description"])
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, fmt.Sprintf("%s/%d", basePath, assistantID), nil)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodDelete, fmt.Sprintf("%s/%d", basePath, assistantID), nil)
|
|
assert.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_AccountScopedShowAndInboxBinding(t *testing.T) {
|
|
router, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Account One")
|
|
otherAccount := seedCaptainAssistantAccount(t, db, "Account Two")
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Description: "Support", Config: json.RawMessage(`{}`), Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
inbox := &model.Inbox{AccountID: account.ID, Name: "Primary", ChannelType: "web_widget"}
|
|
require.NoError(t, db.Create(inbox).Error)
|
|
otherInbox := &model.Inbox{AccountID: otherAccount.ID, Name: "Other", ChannelType: "web_widget"}
|
|
require.NoError(t, db.Create(otherInbox).Error)
|
|
|
|
basePath := "/api/v1/accounts/" + strconv.FormatUint(uint64(account.ID), 10) + "/captain/assistants"
|
|
otherBasePath := "/api/v1/accounts/" + strconv.FormatUint(uint64(otherAccount.ID), 10) + "/captain/assistants"
|
|
|
|
w := captainAssistantJSONRequest(t, router, http.MethodGet, fmt.Sprintf("%s/%d", otherBasePath, assistant.ID), nil)
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, basePath+"/tools", nil)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var tools []map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &tools))
|
|
assert.Len(t, tools, 7)
|
|
assert.Equal(t, "add_contact_note", tools[0]["id"])
|
|
|
|
bindBody := map[string]any{"inbox": map[string]any{"inbox_id": inbox.ID}}
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("%s/%d/inboxes", basePath, assistant.ID), bindBody)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var bound map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &bound))
|
|
assert.Equal(t, float64(inbox.ID), bound["id"])
|
|
assert.NotContains(t, bound, "success")
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, fmt.Sprintf("%s/%d/inboxes", basePath, assistant.ID), nil)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var inboxList map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &inboxList))
|
|
assert.Len(t, inboxList["payload"], 1)
|
|
|
|
wrongBindBody := map[string]any{"inbox": map[string]any{"inbox_id": otherInbox.ID}}
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("%s/%d/inboxes", basePath, assistant.ID), wrongBindBody)
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodDelete, fmt.Sprintf("%s/%d/inboxes/%d", otherBasePath, assistant.ID, inbox.ID), nil)
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodDelete, fmt.Sprintf("%s/%d/inboxes/%d", basePath, assistant.ID, inbox.ID), nil)
|
|
assert.Equal(t, http.StatusNoContent, w.Code)
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_PlaygroundLegacyNoLLMFallback(t *testing.T) {
|
|
router, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Org")
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Description: "Support", Config: json.RawMessage(`{"model":"gpt-test"}`), Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
|
|
body := map[string]any{
|
|
"message_content": "Hello assistant",
|
|
"message_history": []map[string]any{
|
|
{"role": "user", "content": "Previous message"},
|
|
{"role": "assistant", "content": "Previous response", "agent_name": "billing_scenario"},
|
|
},
|
|
}
|
|
w := captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d/playground", account.ID, assistant.ID), body)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var payload map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &payload))
|
|
assert.NotContains(t, payload, "success")
|
|
assert.NotContains(t, payload, "data")
|
|
assert.Equal(t, "Captain assistant response generation is not configured for this account.", payload["content"])
|
|
assert.NotContains(t, payload, "response")
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_PlaygroundDefaultsHistoryAndScopesAccount(t *testing.T) {
|
|
router, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Account One")
|
|
otherAccount := seedCaptainAssistantAccount(t, db, "Account Two")
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Description: "Support", Config: json.RawMessage(`{}`), Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
|
|
body := map[string]any{"message_content": "Hello assistant"}
|
|
w := captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d/playground", account.ID, assistant.ID), body)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d/playground", otherAccount.ID, assistant.ID), body)
|
|
assert.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_PlaygroundV2AppendsCurrentMessageOnce(t *testing.T) {
|
|
provider := &captainPlaygroundFakeProvider{content: "Assistant response"}
|
|
router, db := setupCaptainAssistantHandlerTestWithProvider(t, provider)
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Org")
|
|
account.FeatureFlags = `{"captain_integration_v2":true}`
|
|
require.NoError(t, db.Save(account).Error)
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Description: "Support", Config: json.RawMessage(`{"model":"gpt-test","temperature":0.2}`), Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
|
|
body := map[string]any{
|
|
"message_content": "Hello assistant",
|
|
"message_history": []map[string]any{
|
|
{"role": "user", "content": "Previous message"},
|
|
{"role": "assistant", "content": "Previous response", "agent_name": "billing_scenario"},
|
|
},
|
|
}
|
|
w := captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d/playground", account.ID, assistant.ID), body)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
var payload map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &payload))
|
|
assert.Equal(t, "Assistant response", payload["response"])
|
|
assert.NotContains(t, payload, "content")
|
|
require.Len(t, provider.lastRequest.Messages, 4)
|
|
assert.Equal(t, "Previous message", provider.lastRequest.Messages[1].Content)
|
|
assert.Equal(t, "Previous response", provider.lastRequest.Messages[2].Content)
|
|
assert.Equal(t, "Hello assistant", provider.lastRequest.Messages[3].Content)
|
|
|
|
body = map[string]any{
|
|
"message_content": "Hello assistant",
|
|
"message_history": []map[string]any{{"role": "user", "content": "Hello assistant"}},
|
|
}
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d/playground", account.ID, assistant.ID), body)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
require.Len(t, provider.lastRequest.Messages, 2)
|
|
assert.Equal(t, "Hello assistant", provider.lastRequest.Messages[1].Content)
|
|
}
|
|
|
|
type captainPlaygroundFakeProvider struct {
|
|
content string
|
|
lastRequest llm.ChatRequest
|
|
}
|
|
|
|
func (p *captainPlaygroundFakeProvider) ChatCompletion(ctx context.Context, req llm.ChatRequest) (*llm.ChatResponse, error) {
|
|
p.lastRequest = req
|
|
return &llm.ChatResponse{Choices: []llm.ChatChoice{{Message: llm.ChatMessage{Role: "assistant", Content: p.content}}}}, nil
|
|
}
|
|
|
|
func (p *captainPlaygroundFakeProvider) CreateEmbedding(ctx context.Context, req llm.EmbeddingRequest) (*llm.EmbeddingResponse, error) {
|
|
return &llm.EmbeddingResponse{}, nil
|
|
}
|
|
|
|
func (p *captainPlaygroundFakeProvider) ChatCompletionStream(ctx context.Context, req llm.ChatRequest, onChunk func(llm.StreamChunk) error) error {
|
|
return nil
|
|
}
|