Skip to content

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

19.7 KB
Raw Blame
//
//  Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//

package modelcontext

import (
	"context"
	"encoding/json"
	"testing"

	"github.com/glebarez/sqlite"
	"gorm.io/gorm"

	"ragflow/internal/common"
	"ragflow/internal/entity"
)

func TestMaxTokensFromJSON(t *testing.T) {
	tests := []struct {
		name string
		json json.RawMessage
		want int
	}{
		{name: "integer", json: json.RawMessage(`32000`), want: 32000},
		{name: "fractional number", json: json.RawMessage(`32000.9`), want: 32000},
		{name: "numeric string", json: json.RawMessage(`" 32000 "`), want: 32000},
		{name: "zero", json: json.RawMessage(`0`)},
		{name: "negative", json: json.RawMessage(`-1`)},
		{name: "invalid string", json: json.RawMessage(`"large"`)},
		{name: "null", json: json.RawMessage(`null`)},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			if got := MaxTokensFromJSON(test.json); got != test.want {
				t.Fatalf("MaxTokensFromJSON(%s) = %d, want %d", test.json, got, test.want)
			}
		})
	}
}

func resolveTestContextLength(ctx context.Context, db *gorm.DB, tenantID, modelRef, driver, modelName string) int {
	return ResolveModelContentLength(ctx, db, tenantID, modelRef, driver, modelName)
}

// TestResolveModelContentLength_CompositeReference resolves context_length
// for a composite "model@provider" reference from the provider catalog.
func TestResolveModelContentLength_CompositeReference(t *testing.T) {
	if got := resolveTestContextLength(t.Context(), nil, "", "gpt-4o@openai", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@openai) = %d, want 128000", got)
	}
}

// TestResolveModelContentLength_CompositeReferenceThreePart resolves
// context_length for a composite "model@instance@provider" reference — the
// instance-bearing form used by tenant model instances — from the provider
// catalog.
func TestResolveModelContentLength_CompositeReferenceThreePart(t *testing.T) {
	if got := resolveTestContextLength(t.Context(), nil, "", "gpt-4o@default@openai", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@default@openai) = %d, want 128000", got)
	}
}

// TestResolveModelContentLength_MultiSegmentComposite documents that a
// reference with more than three "@" segments is still a composite ref: the
// leading segments are rejoined into the model name (preserving embedded '@',
// e.g. LM Studio chat models `name@q8_0@lmstudio@LM-Studio`), with instance
// and provider anchored on the right. When the catalog lookup fails it falls
// through to the driver+modelName fallback, and to 0 when no fallback exists.
func TestResolveModelContentLength_MultiSegmentComposite(t *testing.T) {
	if got := resolveTestContextLength(t.Context(), nil, "", "a@b@c@d", "openai", "gpt-4o"); got != 128000 {
		t.Fatalf("resolveTestContextLength(a@b@c@d, openai, gpt-4o) = %d, want 128000 (driver fallback)", got)
	}
	if got := resolveTestContextLength(t.Context(), nil, "", "gpt-4o@default@openai@extra", "", ""); got != 0 {
		t.Fatalf("resolveTestContextLength(gpt-4o@default@openai@extra) = %d, want 0", got)
	}
	modelName, instanceName, providerName, err := common.ParseCompositeModelName("a@b@c@d")
	if err != nil || modelName != "a@b" || instanceName != "c" || providerName != "d" {
		t.Fatalf("ParseCompositeModelName(a@b@c@d) = %q/%q/%q/%v, want a@b/c/d", modelName, instanceName, providerName, err)
	}
}

// TestResolveModelContentLength_DriverModelFallback resolves context_length
// from the resolved driver + bare model name, which needs no database.
func TestResolveModelContentLength_DriverModelFallback(t *testing.T) {
	if got := resolveTestContextLength(t.Context(), nil, "", "", "openai", "gpt-4o"); got != 128000 {
		t.Fatalf("resolveTestContextLength(openai/gpt-4o) = %d, want 128000", got)
	}
}

// TestResolveModelContentLength_Unknown returns 0 for unknown references.
func TestResolveModelContentLength_Unknown(t *testing.T) {
	if got := resolveTestContextLength(t.Context(), nil, "", "no-such-model@no-such-provider", "", ""); got != 0 {
		t.Fatalf("unknown model = %d, want 0", got)
	}
	if got := resolveTestContextLength(t.Context(), nil, "", "", "", ""); got != 0 {
		t.Fatalf("empty reference = %d, want 0", got)
	}
}

// TestResolveModelContentLength_TenantModelUUID resolves context_length for a
// tenant_model UUID row through the provider catalog.
func TestResolveModelContentLength_TenantModelUUID(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, "")

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(uuid) = %d, want 128000", got)
	}
}

// TestResolveModelContentLength_ExtraOverrideUUID verifies that a custom
// "max_tokens" context window in the tenant_model.extra wins over the
// provider catalog's context_length for a UUID reference.
func TestResolveModelContentLength_ExtraOverrideUUID(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 32000}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(uuid+extra) = %d, want 32000 (custom override wins over catalog 128000)", got)
	}
}

// TestResolveModelContentLength_ExtraOverrideComposite verifies the custom
// context window override for a composite reference resolved through the
// tenant's provider/instance/model rows.
func TestResolveModelContentLength_ExtraOverrideComposite(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 32000}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(composite+extra) = %d, want 32000", got)
	}
}

// TestResolveModelContentLength_CustomModelExtraComposite is the core
// custom-model scenario: a model name that is NOT in the provider catalog but
// carries a tenant-configured "max_tokens" override must resolve to that
// override (the catalog cannot provide a value).
func TestResolveModelContentLength_CustomModelExtraComposite(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedCustomChatModel(t, db, "my-local-model", `{"max_tokens": 32000}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "my-local-model@OpenAI", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(custom+extra) = %d, want 32000", got)
	}
	// Without the override the custom model is unknown to the catalog → 0.
	if err := db.Model(&entity.TenantModel{}).
		Where("id = ?", "0123456789abcdef0123456789abcdef").
		Update("extra", "").Error; err != nil {
		t.Fatalf("clear custom model extra: %v", err)
	}
	if got := resolveTestContextLength(ctx, db, "tenant-1", "my-local-model@OpenAI", "", ""); got != 0 {
		t.Fatalf("custom model without extra = %d, want 0", got)
	}
}

// TestResolveModelContentLength_InactiveInstanceCompositeFallsBackToCatalog
// verifies that a composite reference whose instance is inactive does not
// apply the override or the tenant-row catalog read: it falls back to the
// catalog by reference parts (gpt-4o → 128000).
func TestResolveModelContentLength_InactiveInstanceCompositeFallsBackToCatalog(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 32000}`)
	if err := db.Model(&entity.TenantModelInstance{}).
		Where("id = ?", "instance-1").
		Update("status", "inactive").Error; err != nil {
		t.Fatalf("set instance inactive: %v", err)
	}

	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
		t.Fatalf("inactive-instance composite = %d, want catalog 128000", got)
	}
}

// TestResolveModelContentLength_InactiveModelCompositeFallsBackToCatalog
// verifies that a composite reference whose model row is inactive does not
// apply the override or the tenant-row catalog read; it falls back to the
// catalog by reference parts (gpt-4o → 128000).
func TestResolveModelContentLength_InactiveModelCompositeFallsBackToCatalog(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 32000}`)
	if err := db.Model(&entity.TenantModel{}).
		Where("id = ?", "0123456789abcdef0123456789abcdef").
		Update("status", "inactive").Error; err != nil {
		t.Fatalf("set model inactive: %v", err)
	}

	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
		t.Fatalf("inactive-model composite = %d, want catalog 128000", got)
	}
}

// TestResolveModelContentLength_ExtraOverrideStringForm verifies that a
// max_tokens override persisted as a JSON string is still honored (some
// callers persist extra.max_tokens as a string).
func TestResolveModelContentLength_ExtraOverrideStringForm(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": "32000"}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(string-form extra) = %d, want 32000", got)
	}
}

// TestResolveModelContentLength_NonNumericStringExtraFallsBackToCatalog
// verifies that a non-numeric max_tokens string is treated as "no override".
func TestResolveModelContentLength_NonNumericStringExtraFallsBackToCatalog(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": "huge"}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(non-numeric string extra) = %d, want catalog 128000", got)
	}
}

// TestResolveModelContentLength_InvalidExtraFallsBackToCatalog verifies that
// an unparsable extra JSON is treated as "no override" and the catalog
// context_length is used.
func TestResolveModelContentLength_InvalidExtraFallsBackToCatalog(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{bad json`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(invalid extra) = %d, want catalog 128000", got)
	}
}

// TestResolveModelContentLength_ZeroExtraFallsBackToCatalog verifies that a
// non-positive max_tokens override is ignored in favor of the catalog.
func TestResolveModelContentLength_ZeroExtraFallsBackToCatalog(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 0}`)

	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(zero extra) = %d, want catalog 128000", got)
	}
}

// TestResolveModelContentLength_InactiveTenantModel falls through to the
// composite/catalog paths when the tenant model row is not active — even when
// it carries a max_tokens override.
func TestResolveModelContentLength_InactiveTenantModel(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	seedOpenAIChatModel(t, db, `{"max_tokens": 32000}`)
	// Flip the row to inactive.
	if err := db.Model(&entity.TenantModel{}).
		Where("id = ?", "0123456789abcdef0123456789abcdef").
		Update("status", "inactive").Error; err != nil {
		t.Fatalf("set inactive: %v", err)
	}

	// The UUID is not a composite ref, so an inactive row yields 0.
	if got := resolveTestContextLength(ctx, db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != 0 {
		t.Fatalf("inactive tenant model = %d, want 0", got)
	}
}

// seedOpenAIChatModel seeds an active OpenAI gpt-4o tenant model (catalog
// context_length 128000) plus its provider and default instance. extra is the
// tenant_model.extra JSON ("" for none).
func seedOpenAIChatModel(t *testing.T, db *gorm.DB, extra string) {
	t.Helper()
	seedChatModel(t, db, "provider-openai", "OpenAI", "gpt-4o", extra)
}

// seedCustomChatModel seeds an active tenant model whose name is NOT in the
// provider catalog (custom/local model scenario).
func seedCustomChatModel(t *testing.T, db *gorm.DB, modelName, extra string) {
	t.Helper()
	seedChatModel(t, db, "provider-openai", "OpenAI", modelName, extra)
}

func seedChatModel(t *testing.T, db *gorm.DB, providerID, providerName, modelName, extra string) {
	t.Helper()
	seedTenantOwner(t, db)
	if err := db.Create(&entity.TenantModelProvider{
		ID:           providerID,
		UserID:       "tenant-1",
		ProviderName: providerName,
		TenantID:     "tenant-1",
	}).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}
	if err := db.Create(&entity.TenantModelInstance{
		ID:           "instance-1",
		ProviderID:   providerID,
		InstanceName: "default",
		Status:       "active",
	}).Error; err != nil {
		t.Fatalf("create instance: %v", err)
	}
	if err := db.Create(&entity.TenantModel{
		ID:         "0123456789abcdef0123456789abcdef",
		ProviderID: providerID,
		InstanceID: "instance-1",
		ModelName:  modelName,
		ModelType:  int(entity.ModelTypeChat),
		Status:     "active",
		Extra:      extra,
	}).Error; err != nil {
		t.Fatalf("create model: %v", err)
	}
}

func seedTenantOwner(t *testing.T, db *gorm.DB) {
	t.Helper()
	status := entity.TenantMembershipStatusJoined
	if err := db.Create(&entity.UserTenant{
		ID:       "membership-tenant-1",
		UserID:   "tenant-1",
		TenantID: "tenant-1",
		Role:     "owner",
		Status:   &status,
	}).Error; err != nil {
		t.Fatalf("create tenant owner: %v", err)
	}
}

func openModelContextTestDB(t *testing.T) *gorm.DB {
	t.Helper()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})
	if err != nil {
		t.Fatalf("open sqlite: %v", err)
	}
	if err := db.AutoMigrate(&entity.UserTenant{}, &entity.TenantModelProvider{}, &entity.TenantModelInstance{}, &entity.TenantModel{}); err != nil {
		t.Fatalf("migrate: %v", err)
	}
	return db
}

// TestResolveModelContentLength_StoredMistralOCRProvider reads the Mistral
// catalog for models stored under the "Mistral OCR" provider name: through the
// tenant row, through a composite reference without a row, and through the
// driver fallback.
func TestResolveModelContentLength_StoredMistralOCRProvider(t *testing.T) {
	const want = 262144 // mistral-large-latest context_length in conf/models/mistral.json

	if got := resolveTestContextLength(t.Context(), nil, "", "mistral-large-latest@default@Mistral OCR", "", ""); got != want {
		t.Fatalf("composite without tenant row = %d, want %d", got, want)
	}
	if got := resolveTestContextLength(t.Context(), nil, "", "", "Mistral OCR", "mistral-large-latest"); got != want {
		t.Fatalf("driver fallback = %d, want %d", got, want)
	}

	db := openModelContextTestDB(t)
	seedChatModel(t, db, "provider-mistral-ocr", "Mistral OCR", "mistral-large-latest", "")
	if got := resolveTestContextLength(t.Context(), db, "tenant-1", "0123456789abcdef0123456789abcdef", "", ""); got != want {
		t.Fatalf("tenant model id = %d, want %d", got, want)
	}
}

// TestResolveModelContentLength_LegacyCompositeNeverUsesNonDefaultInstance
// verifies that a legacy two-part "model@provider" reference never resolves
// another instance's tenant override. The reference implicitly means the
// "default" instance; when that instance is missing, the resolution must not
// borrow the provider's sole active instance, because that reports the
// context window of a deployment the caller did not select. An explicit
// "model@instance@provider" reference keeps resolving that instance.
func TestResolveModelContentLength_LegacyCompositeNeverUsesNonDefaultInstance(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	if err := db.Create(&entity.TenantModelProvider{
		ID:           "provider-openai",
		UserID:       "tenant-1",
		ProviderName: "OpenAI",
		TenantID:     "tenant-1",
	}).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}
	seedTenantOwner(t, db)
	if err := db.Create(&entity.TenantModelInstance{
		ID:           "instance-prod",
		ProviderID:   "provider-openai",
		InstanceName: "prod",
		Status:       "active",
	}).Error; err != nil {
		t.Fatalf("create instance: %v", err)
	}
	if err := db.Create(&entity.TenantModel{
		ID:         "0123456789abcdef0123456789abcdef",
		ProviderID: "provider-openai",
		InstanceID: "instance-prod",
		ModelName:  "gpt-4o",
		ModelType:  int(entity.ModelTypeChat),
		Status:     "active",
		Extra:      `{"max_tokens": 32000}`,
	}).Error; err != nil {
		t.Fatalf("create model: %v", err)
	}

	// The implicit "default" instance does not exist, so the "prod" instance's
	// tenant override must not answer a two-part reference.
	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@OpenAI) = %d, want 128000 (the default instance is unavailable; another instance must not be substituted)", got)
	}
	// An explicit instance reference still resolves that instance.
	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@prod@OpenAI", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@prod@OpenAI) = %d, want 32000 (explicit instance reference)", got)
	}
}

// TestResolveModelContentLength_LegacyCompositeDoesNotGuessBetweenActiveInstances
// verifies that a legacy two-part reference does not pick one of several
// active instances when the implicit "default" instance is missing. Each
// instance keeps its own override for explicit references.
func TestResolveModelContentLength_LegacyCompositeDoesNotGuessBetweenActiveInstances(t *testing.T) {
	db := openModelContextTestDB(t)
	ctx := t.Context()

	if err := db.Create(&entity.TenantModelProvider{
		ID:           "provider-openai",
		UserID:       "tenant-1",
		ProviderName: "OpenAI",
		TenantID:     "tenant-1",
	}).Error; err != nil {
		t.Fatalf("create provider: %v", err)
	}
	seedTenantOwner(t, db)
	for _, instance := range []*entity.TenantModelInstance{
		{ID: "instance-prod", ProviderID: "provider-openai", InstanceName: "prod", Status: "active"},
		{ID: "instance-staging", ProviderID: "provider-openai", InstanceName: "staging", Status: "active"},
	} {
		if err := db.Create(instance).Error; err != nil {
			t.Fatalf("create instance %s: %v", instance.InstanceName, err)
		}
	}
	for _, model := range []*entity.TenantModel{
		{
			ID: "model-prod", ProviderID: "provider-openai", InstanceID: "instance-prod",
			ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active",
			Extra: `{"max_tokens": 32000}`,
		},
		{
			ID: "model-staging", ProviderID: "provider-openai", InstanceID: "instance-staging",
			ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active",
			Extra: `{"max_tokens": 16000}`,
		},
	} {
		if err := db.Create(model).Error; err != nil {
			t.Fatalf("create model %s: %v", model.ID, err)
		}
	}

	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@OpenAI) = %d, want 128000 (no default instance; no instance may be guessed)", got)
	}
	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@prod@OpenAI", "", ""); got != 32000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@prod@OpenAI) = %d, want 32000", got)
	}
	if got := resolveTestContextLength(ctx, db, "tenant-1", "gpt-4o@staging@OpenAI", "", ""); got != 16000 {
		t.Fatalf("resolveTestContextLength(gpt-4o@staging@OpenAI) = %d, want 16000", got)
	}
}