Rogeeandrogee
74eb006985
* test(shangwutong): cover CID rename reliability * H-43: fix WEB Captain takeover flow * H-48: preserve compatible provider model * H-49: make Captain takeover atomic * H-50: prevent duplicate widget initialization --------- Co-authored-by: Rogee <rogee@ipao.vip>
483 lines
25 KiB
Go
483 lines
25 KiB
Go
package v1
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/alicebob/miniredis/v2"
|
|
"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/redis/go-redis/v9"
|
|
"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) {
|
|
return setupCaptainAssistantHandlerTestWithSummaryProvider(t, nil)
|
|
}
|
|
|
|
func setupCaptainAssistantHandlerTestWithSummaryProvider(t *testing.T, provider llm.Provider) (*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.User{},
|
|
&model.Inbox{},
|
|
&model.Contact{},
|
|
&model.Conversation{},
|
|
&model.Message{},
|
|
&model.ReportingEvent{},
|
|
&model.CaptainAssistant{},
|
|
&model.CaptainInbox{},
|
|
&model.CaptainDocument{},
|
|
&model.CaptainAssistantResponse{},
|
|
&model.CaptainMessageReport{},
|
|
&model.AgentBot{},
|
|
&model.AgentBotInbox{},
|
|
))
|
|
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()
|
|
router.Use(func(c *gin.Context) { c.Set("user_id", uint(9)); c.Next() })
|
|
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)
|
|
assistants.GET("/:assistant_id/stats", handler.Stats)
|
|
assistants.GET("/:assistant_id/summary", handler.Summary)
|
|
assistants.GET("/:assistant_id/drilldown", handler.Drilldown)
|
|
router.POST("/api/v1/accounts/:account_id/captain/message_reports", handler.CreateMessageReport)
|
|
return router, db
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_OverviewDrilldownAndMessageReportContracts(t *testing.T) {
|
|
router, db := setupCaptainAssistantHandlerTestWithSummaryProvider(t, &captainPlaygroundFakeProvider{content: "Captain performance is improving."})
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Reports")
|
|
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: "Support", ChannelType: "api", ChannelID: 1}
|
|
require.NoError(t, db.Create(inbox).Error)
|
|
contact := &model.Contact{AccountID: account.ID, Name: "Ada"}
|
|
require.NoError(t, db.Create(contact).Error)
|
|
displayID := uint(42)
|
|
conversation := &model.Conversation{AccountID: account.ID, InboxID: inbox.ID, ContactID: contact.ID, DisplayID: &displayID, Status: "open", ChannelType: "api", Channel: "api"}
|
|
require.NoError(t, db.Create(conversation).Error)
|
|
message := &model.Message{Base: model.Base{CreatedAt: time.Now().Add(-time.Hour)}, AccountID: account.ID, InboxID: inbox.ID, ConversationID: conversation.ID, SenderID: &assistant.ID, SenderType: "Captain::Assistant", Content: "Answer", ContentType: "text", MessageType: "outgoing"}
|
|
require.NoError(t, db.Create(message).Error)
|
|
require.NoError(t, db.Create(&model.ReportingEvent{AccountID: account.ID, Name: "conversation_captain_inference_resolved", ConversationID: &conversation.ID, EventStartTime: time.Now().Add(-time.Hour), EventEndTime: time.Now().Add(-30 * time.Minute)}).Error)
|
|
|
|
base := fmt.Sprintf("/api/v1/accounts/%d/captain/assistants/%d", account.ID, assistant.ID)
|
|
w := captainAssistantJSONRequest(t, router, http.MethodGet, base+"/stats?range=7&timezone_offset=0", nil)
|
|
require.Equal(t, http.StatusOK, w.Code, w.Body.String())
|
|
stats := map[string]any{}
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &stats))
|
|
for _, key := range []string{"conversations_handled", "auto_resolution_rate", "handoff_rate", "hours_saved", "reopen_rate", "conversation_depth", "knowledge"} {
|
|
assert.Contains(t, stats, key)
|
|
}
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, base+"/drilldown?metric=conversations_handled&range=7", nil)
|
|
require.Equal(t, http.StatusOK, w.Code, w.Body.String())
|
|
drilldown := map[string]any{}
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &drilldown))
|
|
assert.Contains(t, drilldown, "meta")
|
|
assert.Len(t, drilldown["payload"], 1)
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, base+"/drilldown?metric=hours_saved&range=7", nil)
|
|
require.Equal(t, http.StatusUnprocessableEntity, w.Code)
|
|
w = captainAssistantJSONRequest(t, router, http.MethodGet, base+"/summary?range=7", nil)
|
|
require.Equal(t, http.StatusOK, w.Code, w.Body.String())
|
|
summary := map[string]any{}
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &summary))
|
|
assert.NotEmpty(t, summary["message"])
|
|
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/message_reports", account.ID), map[string]any{"message_id": message.ID, "report_reason": "incorrect_information", "description": "Wrong"})
|
|
require.Equal(t, http.StatusOK, w.Code, w.Body.String())
|
|
report := map[string]any{}
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &report))
|
|
assert.Equal(t, "incorrect_information", report["report_reason"])
|
|
assert.Equal(t, float64(message.ID), report["message_id"])
|
|
human := &model.Message{AccountID: account.ID, InboxID: inbox.ID, ConversationID: conversation.ID, SenderType: "User", Content: "Human", ContentType: "text", MessageType: "outgoing"}
|
|
require.NoError(t, db.Create(human).Error)
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/message_reports", account.ID), map[string]any{"message_id": human.ID, "report_reason": "other"})
|
|
require.Equal(t, http.StatusUnprocessableEntity, w.Code)
|
|
otherAccount := seedCaptainAssistantAccount(t, db, "Other")
|
|
w = captainAssistantJSONRequest(t, router, http.MethodPost, fmt.Sprintf("/api/v1/accounts/%d/captain/message_reports", otherAccount.ID), map[string]any{"message_id": message.ID, "report_reason": "other"})
|
|
require.Equal(t, http.StatusNotFound, w.Code)
|
|
}
|
|
|
|
func TestCaptainAssistantSummaryCachesOnlySuccessfulLLMResponses(t *testing.T) {
|
|
_, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Summary")
|
|
user := &model.User{Name: "Ada Lovelace", Email: "ada-summary@example.com"}
|
|
require.NoError(t, db.Create(user).Error)
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
provider := &captainPlaygroundFakeProvider{content: "Ada, Captain performance is improving."}
|
|
mini := miniredis.RunT(t)
|
|
cache := redis.NewClient(&redis.Options{Addr: mini.Addr()})
|
|
t.Cleanup(func() { _ = cache.Close() })
|
|
svc := service.NewCaptainAssistantService(repository.NewCaptainAssistantRepo(db), repository.NewCaptainInboxRepo(db), repository.NewCaptainDocumentRepo(db), repository.NewCaptainAssistantResponseRepo(db), provider, cache)
|
|
|
|
first, err := svc.Summary(context.Background(), account.ID, assistant.ID, user.ID, "7", 0)
|
|
require.NoError(t, err)
|
|
second, err := svc.Summary(context.Background(), account.ID, assistant.ID, user.ID, "7", 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, first, second)
|
|
require.Equal(t, 1, provider.calls)
|
|
|
|
failing := service.NewCaptainAssistantService(repository.NewCaptainAssistantRepo(db), repository.NewCaptainInboxRepo(db), repository.NewCaptainDocumentRepo(db), repository.NewCaptainAssistantResponseRepo(db), &captainPlaygroundFakeProvider{err: errors.New("provider unavailable")})
|
|
_, err = failing.Summary(context.Background(), account.ID, assistant.ID, user.ID, "30", 0)
|
|
require.ErrorContains(t, err, "provider unavailable")
|
|
}
|
|
|
|
func TestCaptainAssistantStatsAndDrilldownUseExactResolvedReopenCohort(t *testing.T) {
|
|
_, db := setupCaptainAssistantHandlerTest(t)
|
|
account := seedCaptainAssistantAccount(t, db, "Captain Cohort")
|
|
assistant := &model.CaptainAssistant{AccountID: account.ID, Name: "Fin", Status: model.AssistantStatusActive}
|
|
require.NoError(t, db.Create(assistant).Error)
|
|
inbox := &model.Inbox{AccountID: account.ID, Name: "Support", ChannelType: "api", ChannelID: 1}
|
|
require.NoError(t, db.Create(inbox).Error)
|
|
contact := &model.Contact{AccountID: account.ID, Name: "Ada"}
|
|
require.NoError(t, db.Create(contact).Error)
|
|
now := time.Now().UTC()
|
|
conversations := make([]model.Conversation, 2)
|
|
for i := range conversations {
|
|
conversations[i] = model.Conversation{AccountID: account.ID, InboxID: inbox.ID, ContactID: contact.ID, Status: "open", ChannelType: "api", Channel: "api"}
|
|
require.NoError(t, db.Create(&conversations[i]).Error)
|
|
require.NoError(t, db.Create(&model.Message{Base: model.Base{CreatedAt: now.Add(-4 * time.Hour)}, AccountID: account.ID, InboxID: inbox.ID, ConversationID: conversations[i].ID, SenderID: &assistant.ID, SenderType: "Captain::Assistant", MessageType: "outgoing"}).Error)
|
|
}
|
|
seedEvent := func(conversationID uint, name string, createdAt, endAt time.Time, value float64) {
|
|
require.NoError(t, db.Create(&model.ReportingEvent{Base: model.Base{CreatedAt: createdAt}, AccountID: account.ID, ConversationID: &conversationID, Name: name, Value: value, EventEndTime: endAt}).Error)
|
|
}
|
|
seedEvent(conversations[0].ID, "conversation_bot_resolved", now.Add(-3*time.Hour), now.Add(-3*time.Hour), 0)
|
|
seedEvent(conversations[0].ID, "conversation_bot_handoff", now.Add(-2*time.Hour), now.Add(-2*time.Hour), 0)
|
|
seedEvent(conversations[0].ID, "conversation_opened", now.Add(-time.Hour), now.Add(-time.Hour), 1)
|
|
seedEvent(conversations[1].ID, "conversation_captain_inference_resolved", now.Add(-3*time.Hour), now.Add(-3*time.Hour), 0)
|
|
seedEvent(conversations[1].ID, "conversation_bot_handoff", now.Add(-2*time.Hour), now.Add(-2*time.Hour), 0)
|
|
seedEvent(conversations[1].ID, "conversation_opened", now.Add(-4*time.Hour), now.Add(-4*time.Hour), 1)
|
|
seedEvent(conversations[1].ID, "conversation_opened", now.Add(-time.Hour), now.Add(-time.Hour), 1)
|
|
svc := service.NewCaptainAssistantService(repository.NewCaptainAssistantRepo(db), repository.NewCaptainInboxRepo(db), repository.NewCaptainDocumentRepo(db), repository.NewCaptainAssistantResponseRepo(db), nil)
|
|
|
|
stats, err := svc.Stats(context.Background(), account.ID, assistant.ID, "7", 0)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 50.0, stats.AutoResolutionRate.Current)
|
|
require.Equal(t, 100.0, stats.ReopenRate.Current)
|
|
for _, metric := range []string{"auto_resolution_rate", "reopen_rate"} {
|
|
result, drilldownErr := svc.Drilldown(context.Background(), account.ID, assistant.ID, service.CaptainDrilldownParams{Metric: metric, Range: "7"})
|
|
require.NoError(t, drilldownErr)
|
|
require.Len(t, result.Payload, 1)
|
|
require.Equal(t, conversations[1].ID, result.Payload[0]["conversation"].(map[string]any)["id"])
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
func TestCaptainAssistantHandler_PlaygroundV2ProviderErrorReturnsChatwootFallback(t *testing.T) {
|
|
provider := &captainPlaygroundFakeProvider{err: errors.New("provider unavailable")}
|
|
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"}`), 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)
|
|
|
|
var payload map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &payload))
|
|
assert.Equal(t, "conversation_handoff", payload["response"])
|
|
assert.Equal(t, false, payload["handoff_tool_called"])
|
|
assert.Contains(t, payload["reasoning"], "Error occurred: llm generation failed: provider unavailable")
|
|
assert.NotContains(t, payload, "content")
|
|
assert.NotContains(t, payload, "success")
|
|
assert.NotContains(t, payload, "data")
|
|
}
|
|
|
|
type captainPlaygroundFakeProvider struct {
|
|
content string
|
|
err error
|
|
calls int
|
|
lastRequest llm.ChatRequest
|
|
}
|
|
|
|
func (p *captainPlaygroundFakeProvider) ChatCompletion(ctx context.Context, req llm.ChatRequest) (*llm.ChatResponse, error) {
|
|
p.calls++
|
|
p.lastRequest = req
|
|
if p.err != nil {
|
|
return nil, p.err
|
|
}
|
|
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
|
|
}
|