Function TestAdvisorGating_Disabled

coderd/x/chatd/chatd_test.go:9651–9720

(t *testing.T)

}

func TestAdvisorGating_Disabled(t *testing.T) {
	t.Parallel()

	db, ps := dbtestutil.NewDB(t)
	ctx := testutil.Context(t, testutil.WaitLong)

	var toolsMu sync.Mutex
	var capturedTools []string
	var capturedMessages []chattest.OpenAIMessage

	openAIURL := chattest.NewOpenAI(t, func(req *chattest.OpenAIRequest) chattest.OpenAIResponse {
		if !req.Stream {
			return chattest.OpenAINonStreamingResponse("title")
		}

		names := make([]string, 0, len(req.Tools))
		for _, tool := range req.Tools {
			names = append(names, tool.Function.Name)
		}
		toolsMu.Lock()
		capturedTools = names
		capturedMessages = append([]chattest.OpenAIMessage(nil), req.Messages...)
		toolsMu.Unlock()

		return chattest.OpenAIStreamingResponse(
			chattest.OpenAITextChunks("advisor is not available")...,
		)
	})

	user, org, model := seedChatDependenciesWithProvider(t, db, "openai-compat", openAIURL)
	seedAdvisorConfig(ctx, t, db, codersdk.AdvisorConfig{
		Enabled:         false,
		MaxUsesPerRun:   3,
		MaxOutputTokens: 16384,
	})
	server := newActiveTestServer(t, db, ps)

	chat, err := server.CreateChat(ctx, chatd.CreateOptions{
		OrganizationID: org.ID,
		OwnerID:        user.ID,
		Title:          "advisor-disabled",
		ModelConfigID:  model.ID,
		InitialUserContent: []codersdk.ChatMessagePart{
			codersdk.ChatMessageText("hello"),
		},
	})
	require.NoError(t, err)

	require.Eventually(t, func() bool {
		got, getErr := db.GetChatByID(ctx, chat.ID)
		if getErr != nil {
			return false
		}
		return got.Status == database.ChatStatusWaiting ||
			got.Status == database.ChatStatusError
	}, testutil.WaitLong, testutil.IntervalFast)

	toolsMu.Lock()