Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

17.4 KB
Raw Blame
package models

import (
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
)

func newXiaomiServer(t *testing.T, expectedPath string, handler func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter)) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != expectedPath {
			t.Errorf("expected path=%s, got %s", expectedPath, r.URL.Path)
			return
		}
		if got := r.Header.Get("api-key"); got != "test-key" {
			t.Errorf("expected api-key=test-key, got %q", got)
			return
		}
		if got := r.Header.Get("Authorization"); got != "" {
			t.Errorf("expected no Authorization header, got %q", got)
			return
		}
		if got := r.Header.Get("Content-Type"); !strings.HasPrefix(got, "application/json") {
			t.Errorf("expected Content-Type to start with application/json, got %q", got)
			return
		}
		raw, err := io.ReadAll(r.Body)
		if err != nil {
			t.Errorf("read body: %v", err)
			return
		}
		// GET requests (e.g. ListModels) carry no body.
		var body map[string]interface{}
		if len(raw) > 0 {
			if err := json.Unmarshal(raw, &body); err != nil {
				t.Errorf("unmarshal: %v\nraw=%s", err, string(raw))
				return
			}
		}
		handler(t, r, body, w)
	}))
}

func newXiaomiForTest(baseURL string) *XiaomiModel {
	return NewXiaomiModel(
		map[string]string{"default": baseURL},
		URLSuffix{Chat: "v1/chat/completions"},
	)
}

func TestXiaomiName(t *testing.T) {
	if got := newXiaomiForTest("http://unused").Name(); got != "xiaomi" {
		t.Errorf("Name()=%q, want xiaomi", got)
	}
}

func TestXiaomiFactory(t *testing.T) {
	driver, err := NewModelFactory().CreateModelDriver("Xiaomi", map[string]string{"default": "http://unused"}, URLSuffix{})
	if err != nil {
		t.Fatalf("factory: %v", err)
	}
	if _, ok := driver.(*XiaomiModel); !ok {
		t.Fatalf("driver type=%T, want *XiaomiModel", driver)
	}
}

func TestXiaomiNewModelWithCustomDefaultTransport(t *testing.T) {
	original := http.DefaultTransport
	http.DefaultTransport = roundTripperFunc(func(*http.Request) (*http.Response, error) {
		return nil, nil
	})
	t.Cleanup(func() {
		http.DefaultTransport = original
	})

	if model := NewXiaomiModel(map[string]string{"default": "http://unused"}, URLSuffix{}); model == nil {
		t.Fatal("NewXiaomiModel returned nil")
	}
}

func TestXiaomiChatHappyPath(t *testing.T) {
	withSSRFBypass(t)
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		if body["model"] != "mimo-v2.5-pro" {
			t.Errorf("model=%v", body["model"])
		}
		if body["stream"] != false {
			t.Errorf("stream=%v want false", body["stream"])
		}
		if body["max_completion_tokens"] != float64(1024) {
			t.Errorf("max_completion_tokens=%v", body["max_completion_tokens"])
		}
		thinking, ok := body["thinking"].(map[string]interface{})
		if !ok || thinking["type"] != "disabled" {
			t.Errorf("thinking=%v", body["thinking"])
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{
					"role":    "assistant",
					"content": "pong",
				},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	maxTokens := 1024
	thinking := false
	ctx := t.Context()
	resp, err := newXiaomiForTest(srv.URL).ChatWithMessages(ctx,
		"mimo-v2.5-pro",
		[]Message{{Role: "user", Content: "ping"}},
		&APIConfig{ApiKey: &apiKey},
		&ChatConfig{MaxTokens: &maxTokens, Thinking: &thinking}, nil,
	)
	if err != nil {
		t.Fatalf("ChatWithMessages: %v", err)
	}
	if resp.Answer == nil || *resp.Answer != "pong" {
		t.Fatalf("answer=%v", resp.Answer)
	}
	if resp.ReasonContent == nil || *resp.ReasonContent != "" {
		t.Fatalf("reasoning=%v", resp.ReasonContent)
	}
}

func TestXiaomiUsesEmptyRegionBaseURLOverride(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{
					"content": "pong",
				},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	m := NewXiaomiModel(
		map[string]string{"default": srv.URL},
		URLSuffix{Chat: "v1/chat/completions"},
	)
	resp, err := m.ChatWithMessages(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "ping"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err != nil {
		t.Fatalf("ChatWithMessages: %v", err)
	}
	if resp.Answer == nil || *resp.Answer != "pong" {
		t.Fatalf("answer=%v", resp.Answer)
	}
}

func TestXiaomiAPIConfigBaseURLOverridesRegionMap(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/override/chat", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{
					"content": "override",
				},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	baseURL := srv.URL
	m := NewXiaomiModel(
		map[string]string{"default": "http://unused"},
		URLSuffix{Chat: "override/chat"},
	)
	resp, err := m.ChatWithMessages(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "ping"}}, &APIConfig{ApiKey: &apiKey, BaseURL: &baseURL}, nil, nil)
	if err != nil {
		t.Fatalf("ChatWithMessages: %v", err)
	}
	if resp.Answer == nil || *resp.Answer != "override" {
		t.Fatalf("answer=%v", resp.Answer)
	}
}

func TestXiaomiChatExtractsReasoningContent(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{
					"content":           "final",
					"reasoning_content": "think",
				},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	resp, err := newXiaomiForTest(srv.URL).ChatWithMessages(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "x"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err != nil {
		t.Fatalf("ChatWithMessages: %v", err)
	}
	if *resp.Answer != "final" || *resp.ReasonContent != "think" {
		t.Fatalf("response=%+v", resp)
	}
}

func TestXiaomiChatRequiresInputs(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	apiKey := "test-key"
	m := newXiaomiForTest("http://unused")
	if _, err := m.ChatWithMessages(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "x"}}, &APIConfig{}, nil, nil); err == nil || !strings.Contains(err.Error(), "api key is required") {
		t.Errorf("api key guard: %v", err)
	}
	if _, err := m.ChatWithMessages(ctx, "", []Message{{Role: "user", Content: "x"}}, &APIConfig{ApiKey: &apiKey}, nil, nil); err == nil || !strings.Contains(err.Error(), "model name is required") {
		t.Errorf("model guard: %v", err)
	}
	if _, err := m.ChatWithMessages(ctx, "mimo-v2.5-pro", nil, &APIConfig{ApiKey: &apiKey}, nil, nil); err == nil || !strings.Contains(err.Error(), "messages is empty") {
		t.Errorf("messages guard: %v", err)
	}
}

func TestXiaomiChatRejectsHTTPError(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		w.WriteHeader(http.StatusUnauthorized)
		_, _ = io.WriteString(w, `{"error":"unauthorized"}`)
	})
	defer srv.Close()

	apiKey := "test-key"
	_, err := newXiaomiForTest(srv.URL).ChatWithMessages(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "x"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "401") {
		t.Errorf("expected 401 propagated, got %v", err)
	}
}

func TestXiaomiStreamHappyPath(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		if body["stream"] != true {
			t.Errorf("stream=%v want true", body["stream"])
		}
		streamOptions, ok := body["stream_options"].(map[string]interface{})
		if !ok || streamOptions["include_usage"] != true {
			t.Errorf("stream_options=%#v, want include_usage=true", body["stream_options"])
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = io.WriteString(w,
			`data: {"choices":[{"delta":{"reasoning_content":"step "}}]}`+"\n\n"+
				`data: {"choices":[{"delta":{"content":"Hello"}}]}`+"\n\n"+
				`data: {"choices":[{"delta":{"content":" world"},"finish_reason":"stop"}]}`+"\n\n",
		)
	})
	defer srv.Close()

	apiKey := "test-key"
	var content, reasoning []string
	var sawDone bool
	err := newXiaomiForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"mimo-v2.5-pro",
		[]Message{{Role: "user", Content: "hi"}},
		&APIConfig{ApiKey: &apiKey},
		nil,
		nil,
		func(c *string, r *string) error {
			if c != nil && *c == "[DONE]" {
				sawDone = true
				return nil
			}
			if c != nil {
				content = append(content, *c)
			}
			if r != nil {
				reasoning = append(reasoning, *r)
			}
			return nil
		},
	)
	if err != nil {
		t.Fatalf("stream: %v", err)
	}
	if strings.Join(content, "") != "Hello world" {
		t.Errorf("content=%v", content)
	}
	if strings.Join(reasoning, "") != "step " {
		t.Errorf("reasoning=%v", reasoning)
	}
	if !sawDone {
		t.Error("expected [DONE] sentinel")
	}
}

func TestXiaomiStreamHandlesCRLFFrames(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = io.WriteString(w,
			"data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\r\n\r\n"+
				"data: {\"choices\":[{\"delta\":{\"content\":\" world\"},\"finish_reason\":\"stop\"}]}\r\n\r\n",
		)
	})
	defer srv.Close()

	apiKey := "test-key"
	var content []string
	err := newXiaomiForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"mimo-v2.5-pro",
		[]Message{{Role: "user", Content: "hi"}},
		&APIConfig{ApiKey: &apiKey},
		nil,
		nil,
		func(c *string, _ *string) error {
			if c != nil && *c != "[DONE]" {
				content = append(content, *c)
			}
			return nil
		},
	)
	if err != nil {
		t.Fatalf("stream: %v", err)
	}
	if strings.Join(content, "") != "Hello world" {
		t.Errorf("content=%v", content)
	}
}

func TestXiaomiStreamRejectsMalformedFrame(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/chat/completions", func(t *testing.T, _ *http.Request, _ map[string]interface{}, w http.ResponseWriter) {
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = io.WriteString(w, "data: {bad json}\n\n")
	})
	defer srv.Close()

	apiKey := "test-key"
	// Malformed SSE frames abort the stream: Xiaomi now uses the strict
	// OpenAIParserConfig shared by every OpenAI-compatible driver.
	err := newXiaomiForTest(srv.URL).ChatStreamlyWithSender(ctx, "mimo-v2.5-pro", []Message{{Role: "user", Content: "x"}}, &APIConfig{ApiKey: &apiKey}, nil, nil, func(*string, *string) error { return nil })
	if err == nil {
		t.Error("expected error on malformed frame, got nil")
	}
}

func TestXiaomiUnsupportedMethods(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	m := newXiaomiForTest("http://unused")
	model := "mimo-v2.5-pro"
	apiKey := "test-key"
	cfg := &APIConfig{ApiKey: &apiKey}

	if _, err := m.Embed(ctx, &model, EmbedRequest{Texts: []string{"x"}}, cfg, nil, nil); err == nil || !strings.Contains(err.Error(), "no such method") {
		t.Errorf("Embed: %v", err)
	}
	if _, err := m.Rerank(ctx, &model, RerankRequest{Query: "q", Documents: []string{"d"}}, cfg, nil, nil); err == nil || !strings.Contains(err.Error(), "no such method") {
		t.Errorf("Rerank: %v", err)
	}
	// TranscribeAudio IS implemented; with nil file it returns input validation error.
	if _, err := m.TranscribeAudio(ctx, &model, nil, cfg, nil, nil); err == nil || !strings.Contains(err.Error(), "file is missing") {
		t.Errorf("TranscribeAudio: %v", err)
	}
	// AudioSpeech IS implemented; with nil content it returns input validation error.
	if _, err := m.AudioSpeech(ctx, &model, nil, cfg, nil, nil); err == nil || !strings.Contains(err.Error(), "audio content is empty") {
		t.Errorf("AudioSpeech: %v", err)
	}
	if _, err := m.OCRFile(ctx, &model, nil, nil, cfg, nil, nil); err == nil || !strings.Contains(err.Error(), "no such method") {
		t.Errorf("OCRFile: %v", err)
	}
}

func newXiaomiListModelsForTest(baseURL string) *XiaomiModel {
	return NewXiaomiModel(
		map[string]string{"default": baseURL},
		URLSuffix{Chat: "v1/chat/completions", Models: "models"},
	)
}

func TestXiaomiListModelsHappyPath(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/models", func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		if r.Method != http.MethodGet {
			t.Errorf("expected method GET, got %s", r.Method)
		}
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"mimo-v2.5","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-pro","object":"model","owned_by":"xiaomi"}]}`))
	})
	defer srv.Close()

	m := newXiaomiListModelsForTest(srv.URL + "/v1")
	apiKey := "test-key"
	models, err := m.ListModels(ctx, &APIConfig{ApiKey: &apiKey})
	if err != nil {
		t.Fatalf("ListModels: %v", err)
	}

	names := make([]string, 0, len(models))
	for _, model := range models {
		names = append(names, model.Name)
	}
	if got := strings.Join(names, ","); got != "mimo-v2.5,mimo-v2.5-pro" {
		t.Fatalf("models=%v, want [mimo-v2.5 mimo-v2.5-pro]", names)
	}

	// The remote payload only carries ids, so the catalog must backfill types.
	wantTypes := []string{"chat", "vision"}
	for _, want := range wantTypes {
		found := false
		for _, got := range models[0].ModelTypes {
			if got == want {
				found = true
				break
			}
		}
		if !found {
			t.Errorf("mimo-v2.5 model_types=%v, want to contain %q", models[0].ModelTypes, want)
		}
	}
}

// The upstream payload only carries ids, and it advertises models the local
// catalog does not list (the tts variants in Xiaomi's docs). Those entries
// must still come back typed so the picker does not show them as chat-only.
func TestXiaomiListModelsTypesModelsMissingFromCatalog(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/models", func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"mimo-v2.5","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-asr","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-pro","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-tts","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-tts-voiceclone","object":"model","owned_by":"xiaomi"},{"id":"mimo-v2.5-tts-voicedesign","object":"model","owned_by":"xiaomi"}]}`))
	})
	defer srv.Close()

	m := newXiaomiListModelsForTest(srv.URL + "/v1")
	apiKey := "test-key"
	models, err := m.ListModels(ctx, &APIConfig{ApiKey: &apiKey})
	if err != nil {
		t.Fatalf("ListModels: %v", err)
	}

	byName := make(map[string][]string, len(models))
	for _, model := range models {
		byName[model.Name] = model.ModelTypes
	}
	if len(byName) != 6 {
		t.Fatalf("models=%v, want 6 entries", byName)
	}
	for _, name := range []string{"mimo-v2.5-tts-voiceclone", "mimo-v2.5-tts-voicedesign"} {
		types, ok := byName[name]
		if !ok {
			t.Fatalf("model %q missing from %v", name, byName)
		}
		if len(types) != 1 || types[0] != "tts" {
			t.Errorf("%s model_types=%v, want [tts]", name, types)
		}
	}
}

func TestXiaomiListModelsRejectsProviderError(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := newXiaomiServer(t, "/v1/models", func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		http.Error(w, "bad key", http.StatusUnauthorized)
	})
	defer srv.Close()

	m := newXiaomiListModelsForTest(srv.URL + "/v1")
	apiKey := "test-key"
	if _, err := m.ListModels(ctx, &APIConfig{ApiKey: &apiKey}); err == nil || !strings.Contains(err.Error(), "401") {
		t.Errorf("ListModels error=%v, want status 401", err)
	}
}

func TestXiaomiListModelsRequiresURLSuffix(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	// No server: the driver must fail before issuing a request.
	m := newXiaomiForTest("http://unused")
	apiKey := "test-key"
	if _, err := m.ListModels(ctx, &APIConfig{ApiKey: &apiKey}); err == nil || !strings.Contains(err.Error(), "models URL suffix is not configured") {
		t.Errorf("ListModels error=%v, want missing URL suffix", err)
	}
}

func TestXiaomiCheckConnectionUsesListModels(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	apiKey := "test-key"

	srv := newXiaomiServer(t, "/v1/models", func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"mimo-v2.5-pro"}]}`))
	})
	defer srv.Close()

	if err := newXiaomiListModelsForTest(srv.URL+"/v1").CheckConnection(ctx, &APIConfig{ApiKey: &apiKey}); err != nil {
		t.Errorf("CheckConnection: %v", err)
	}

	rejected := newXiaomiServer(t, "/v1/models", func(t *testing.T, r *http.Request, body map[string]interface{}, w http.ResponseWriter) {
		http.Error(w, "bad key", http.StatusUnauthorized)
	})
	defer rejected.Close()

	if err := newXiaomiListModelsForTest(rejected.URL+"/v1").CheckConnection(ctx, &APIConfig{ApiKey: &apiKey}); err == nil {
		t.Error("CheckConnection: expected an error for a rejected key")
	}
}