RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
Go: add integration test (#19485)
Jin Hai3e30a476233f
diff --git a/go.mod b/go.modindex 96d38884c7..8044548db1 100644--- a/go.mod+++ b/go.mod@@ -58,6 +58,7 @@ require (github.com/signintech/gopdf v0.36.1github.com/siongui/gojianfan v0.0.0-20210926212422-2f175ac615degithub.com/spf13/viper v1.18.2+ github.com/stretchr/testify v1.11.1github.com/ucloud/ucloud-sandbox-sdk-go v0.0.0-20260807065450-08464aef9ed5github.com/xuri/excelize/v2 v2.11.0github.com/yfedoseev/office_oxide/go v0.1.9@@ -89,11 +90,13 @@ require (github.com/PuerkitoBio/goquery v1.9.2 // indirectgithub.com/andybalholm/cascadia v1.3.2 // indirectgithub.com/apache/arrow/go/v15 v15.0.2 // indirect+ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirectgithub.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirectgithub.com/goccy/go-json v0.10.5 // indirectgithub.com/google/flatbuffers v23.5.26+incompatible // indirectgithub.com/json-iterator/go v1.1.12 // indirectgithub.com/pierrec/lz4/v4 v4.1.18 // indirect+ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirectgolang.org/x/mod v0.38.0 // indirectgolang.org/x/telemetry v0.0.0-20260708182218-49f421fb7959 // indirectgolang.org/x/tools v0.48.0 // indirectdiff --git a/test/api/config.go b/test/api/config.gonew file mode 100644index 0000000000..385704f486--- /dev/null+++ b/test/api/config.go@@ -0,0 +1,322 @@+//go:build integration++//+// 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 api++import (+ "bytes"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "os"+ "strconv"+ "strings"+)++var TestConfig *ServerTestConfig++func init() {+ TestConfig = InitServerTestConfig()+ if TestConfig == nil {+ panic("TestConfig is nil")+ }+}++type ServerTestConfig struct {+ Priority int+ HostAddress string+ APIVersion string+ ZhipuAPIKey string+ SiliconFlowAPIKey string+ Email string+ Password string+ AuthToken string+ APIKey string++ InvalidAPIKey string+ InvalidID string+ DatasetNameLimit int+ DocumentNameLimit int+ ChatAssistantNameLimit int+ SessionWithChatNameLimit int++ DefaultDataSetParser map[string]interface{}+}++func InitServerTestConfig() *ServerTestConfig {+ //fmt.Fprintf(os.Stderr, "InitServerTestConfig start\n")+ var priority int+ var err error+ testPriorityStr := os.Getenv("TEST_PRIORITY")+ if testPriorityStr == "" {+ priority = 0+ } else {+ priority, err = strconv.Atoi(testPriorityStr)+ if err != nil {+ fmt.Fprintf(os.Stderr, "TEST_PRIORITY is not a valid integer: %v\n", err)+ return nil+ }+ }++ hostAddress := os.Getenv("HOST_ADDRESS")+ if hostAddress == "" {+ hostAddress = "http://127.0.0.1:9384"+ }++ zhipuAPIKey := os.Getenv("ZHIPU_AI_API_KEY")+ if zhipuAPIKey == "" {+ fmt.Fprintf(os.Stderr, "ZHIPU_AI_API_KEY is not set\n")+ return nil+ }++ siliconFlowAPIKey := os.Getenv("SILICONFLOW_API_KEY")+ if siliconFlowAPIKey == "" {+ fmt.Fprintf(os.Stderr, "SILICONFLOW_API_KEY is not set\n")+ return nil+ }++ email := os.Getenv("RAGFLOW_TEST_EMAIL")+ if email == "" {+ email = "[email protected]"+ }++ password := os.Getenv("RAGFLOW_TEST_PASSWORD")+ if password == "" {+ password = "ctAseGvejiaSWWZ88T/m4FQVOpQyUvP+x7sXtdv3feqZACiQleuewkUi35E16wSd5C5QcnkkcV9cYc8TKPTRZlxappDuirxghxoOvFcJxFU4ixLsD\nfN33jCHRoDUW81IH9zjij/vaw8IbVyb6vuwg6MX6inOEBRRzVbRYxXOu1wkWY6SsI8X70oF9aeLFp/PzQpjoe/YbSqpTq8qqrmHzn9vO+yvyYyvmDsphXe\nX8f7fp9c7vUsfOCkM+gHY3PadG+QHa7KI7mzTKgUTZImK6BZtfRBATDTthEUbbaTewY4H0MnWiCeeDhcbeQao6cFy1To8pE3RpmxnGnS8BsBn8w=="+ }++ invalidID := "00000000000000000000000000000000"++ defaultParserConfig := map[string]interface{}{+ "layout_recognize": "DeepDOC",+ "chunk_token_num": 512,+ "delimiter": "\n",+ "auto_keywords": 0,+ "auto_questions": 0,+ "html4excel": false,+ "image_context_size": 0,+ "table_context_size": 0,+ "topn_tags": 3,+ "llm_id": "glm-4-flash@CI@ZHIPU-AI",+ "parent_child": map[string]interface{}{+ "use_parent_child": false,+ "children_delimiter": "\n",+ },+ "children_delimiter": "",+ }++ serverTestConfig := ServerTestConfig{+ Priority: priority,+ HostAddress: hostAddress,+ APIVersion: "v1",+ ZhipuAPIKey: zhipuAPIKey,+ SiliconFlowAPIKey: siliconFlowAPIKey,+ Email: email,+ Password: password,+ InvalidAPIKey: "invalidapikey",+ InvalidID: invalidID,+ DatasetNameLimit: 100,+ DocumentNameLimit: 100,+ ChatAssistantNameLimit: 100,+ SessionWithChatNameLimit: 100,+ DefaultDataSetParser: defaultParserConfig,+ }++ //fmt.Fprintf(os.Stderr, "InitServerTestConfig init successfully\n")+ return &serverTestConfig+}++func (c *ServerTestConfig) apiBase() string {+ return fmt.Sprintf("%s/api/%s", c.HostAddress, c.APIVersion)+}++func (c *ServerTestConfig) buildHeaders(extra map[string]string) http.Header {+ h := make(http.Header)+ h.Set("Content-Type", "application/json")+ for k, v := range extra {+ h.Set(k, v)+ }+ if c.AuthToken != "" && h.Get("Authorization") == "" {+ h.Set("Authorization", "Bearer "+c.AuthToken)+ } else {+ if c.APIKey != "" && h.Get("Authorization") == "" {+ h.Set("Authorization", "Bearer "+c.APIKey)+ }+ }++ return h+}++func (c *ServerTestConfig) RequestJSON(method, path string, body, params map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ var bodyReader io.Reader+ if body != nil {+ b, err := json.Marshal(body)+ if err != nil {+ return nil, err+ }+ bodyReader = bytes.NewReader(b)+ }++ u, err := url.Parse(c.apiBase() + "/" + strings.TrimLeft(path, "/"))+ if err != nil {+ return nil, err+ }+ q := u.Query()+ for k, v := range params {+ q.Set(k, fmt.Sprint(v))+ }+ u.RawQuery = q.Encode()++ req, err := http.NewRequest(method, u.String(), bodyReader)+ if err != nil {+ return nil, err+ }+ req.Header = c.buildHeaders(extraHeaders)+ return http.DefaultClient.Do(req)+}++func (c *ServerTestConfig) GetJSON(path string, params map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ return c.RequestJSON(http.MethodGet, path, nil, params, extraHeaders)+}++func (c *ServerTestConfig) PostJSON(path string, body map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ return c.RequestJSON(http.MethodPost, path, body, nil, extraHeaders)+}++func (c *ServerTestConfig) DeleteJSON(path string, body map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ return c.RequestJSON(http.MethodDelete, path, body, nil, extraHeaders)+}++func (c *ServerTestConfig) PutJSON(path string, body map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ return c.RequestJSON(http.MethodPut, path, body, nil, extraHeaders)+}++func (c *ServerTestConfig) PatchJSON(path string, body map[string]interface{}, extraHeaders map[string]string) (*http.Response, error) {+ return c.RequestJSON(http.MethodPatch, path, body, nil, extraHeaders)+}++func (c *ServerTestConfig) decodeJSONBody(body io.Reader) (map[string]interface{}, error) {+ b, err := io.ReadAll(body)+ if err != nil {+ return nil, err+ }+ var payload map[string]interface{}+ if err = json.Unmarshal(b, &payload); err != nil {+ return nil, err+ }+ return payload, nil+}++func (c *ServerTestConfig) Login() error {+ // Register (ignore already registered error)+ registerResp, err := c.PostJSON("/users", map[string]interface{}{+ "email": c.Email,+ "nickname": "qa",+ "password": c.Password,+ }, nil)+ if err != nil {+ return fmt.Errorf("register request failed: %w", err)+ }+ registerPayload, err := c.decodeJSONBody(registerResp.Body)+ registerResp.Body.Close()+ if err != nil {+ return fmt.Errorf("failed to decode register response: %w", err)+ }+ if registerResp.StatusCode != http.StatusOK {+ return fmt.Errorf("register failed: status=%d, payload=%v", registerResp.StatusCode, registerPayload)+ }+ registerCode, _ := registerPayload["code"].(float64)+ registerMessage, _ := registerPayload["message"].(string)+ if int(registerCode) != 0 && !strings.Contains(registerMessage, "has already registered") {+ return fmt.Errorf("register failed: code=%v, message=%s", registerPayload["code"], registerMessage)+ }++ // Login+ loginResp, err := c.PostJSON("/auth/login", map[string]interface{}{+ "email": c.Email,+ "password": c.Password,+ }, nil)+ if err != nil {+ return fmt.Errorf("login request failed: %w", err)+ }+ authToken := loginResp.Header.Get("Authorization")+ loginResp.Body.Close()+ if authToken == "" {+ return fmt.Errorf("login response missing Authorization header")+ }++ c.AuthToken = authToken++ // Get system token+ tokenResp, err := c.PostJSON("/system/tokens", nil, map[string]string{+ "Authorization": authToken,+ })+ if err != nil {+ return fmt.Errorf("system token request failed: %w", err)+ }+ tokenPayload, err := c.decodeJSONBody(tokenResp.Body)+ tokenResp.Body.Close()+ if err != nil {+ return fmt.Errorf("failed to decode token response: %w", err)+ }+ if tokenResp.StatusCode != http.StatusOK {+ return fmt.Errorf("system token failed: status=%d, payload=%v", tokenResp.StatusCode, tokenPayload)+ }+ tokenData, ok := tokenPayload["data"].(map[string]interface{})+ if !ok {+ return fmt.Errorf("system token response data is not an object: %v", tokenPayload)+ }+ apiKey, ok := tokenData["token"].(string)+ if !ok || apiKey == "" {+ return fmt.Errorf("system token response data.token is not a valid string: %v", tokenData)+ }++ c.APIKey = apiKey+ return nil+}++func (c *ServerTestConfig) Logout() error {+ resp, err := c.PostJSON("/auth/logout", nil, nil)+ if err != nil {+ return err+ }+ defer resp.Body.Close()++ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return fmt.Errorf("failed to read logout response: %w", err)+ }+ var payload map[string]interface{}+ if err = json.Unmarshal(body, &payload); err != nil {+ return fmt.Errorf("failed to decode logout response: %w", err)+ }++ if resp.StatusCode != http.StatusOK {+ return fmt.Errorf("logout failed: status=%d, payload=%v", resp.StatusCode, payload)+ }+ code, _ := payload["code"].(float64)+ if int(code) != 0 {+ return fmt.Errorf("logout failed: code=%v, message=%v", payload["code"], payload["message"])+ }++ c.APIKey = ""+ c.AuthToken = ""+ return nil+}diff --git a/test/api/dataset_api_test.go b/test/api/dataset_api_test.gonew file mode 100644index 0000000000..c191879073--- /dev/null+++ b/test/api/dataset_api_test.go@@ -0,0 +1,581 @@+//go:build integration++//+// 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 api++import (+ "bytes"+ "encoding/base64"+ "encoding/json"+ "fmt"+ "image"+ "image/color"+ "image/draw"+ "image/png"+ "io"+ "net/http"+ "strings"+ "testing"+)++func decodeResponseJSON(resp *http.Response) (map[string]interface{}, error) {+ defer resp.Body.Close()+ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return nil, err+ }+ var payload map[string]interface{}+ if err = json.Unmarshal(body, &payload); err != nil {+ return nil, err+ }+ return payload, nil+}++func requireStatusCode(t *testing.T, resp *http.Response, expected int) map[string]interface{} {+ t.Helper()+ if resp.StatusCode != expected {+ t.Fatalf("expected status code %d, got %d", expected, resp.StatusCode)+ }+ payload, err := decodeResponseJSON(resp)+ if err != nil {+ t.Fatalf("failed to decode response: %v", err)+ }+ return payload+}++func requireCodeZero(t *testing.T, payload map[string]interface{}) {+ t.Helper()+ code, ok := payload["code"].(float64)+ if !ok || int(code) != 0 {+ t.Fatalf("expected code 0, got %v, payload: %v", payload["code"], payload)+ }+}++func clearDatasets(t *testing.T) {+ t.Helper()+ resp, err := TestConfig.DeleteJSON("/datasets", map[string]interface{}{"ids": nil, "delete_all": true}, nil)+ if err != nil {+ t.Fatalf("clear datasets request failed: %v", err)+ }+ payload := requireStatusCode(t, resp, http.StatusOK)+ code, _ := payload["code"].(float64)+ if int(code) != 0 && int(code) != 102 {+ t.Fatalf("clear datasets failed: code=%v, payload=%v", payload["code"], payload)+ }+}++func jsonDeepEqual(a, b interface{}) bool {+ switch av := a.(type) {+ case float64:+ switch bv := b.(type) {+ case float64:+ return av == bv+ case int:+ return av == float64(bv)+ case int64:+ return av == float64(bv)+ default:+ return false+ }+ case int:+ return jsonDeepEqual(float64(av), b)+ case int64:+ return jsonDeepEqual(float64(av), b)+ case string, bool, nil:+ return a == b+ case []interface{}:+ bv, ok := b.([]interface{})+ if !ok || len(av) != len(bv) {+ return false+ }+ for i := range av {+ if !jsonDeepEqual(av[i], bv[i]) {+ return false+ }+ }+ return true+ case map[string]interface{}:+ bv, ok := b.(map[string]interface{})+ if !ok || len(av) != len(bv) {+ return false+ }+ for k, v := range av {+ bvVal, ok := bv[k]+ if !ok || !jsonDeepEqual(v, bvVal) {+ return false+ }+ }+ return true+ default:+ return a == b+ }+}++func TestDatasetCRUDCycle(t *testing.T) {+ clearDatasets(t)+ // Create+ createResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": "restful_dataset_crud"}, nil)+ if err != nil {+ t.Fatalf("create dataset request failed: %v", err)+ }+ createPayload := requireStatusCode(t, createResp, http.StatusOK)+ requireCodeZero(t, createPayload)+ createData, ok := createPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("create response data is not an object: %v", createPayload)+ }+ datasetID, ok := createData["id"].(string)+ if !ok || datasetID == "" {+ t.Fatalf("create response data.id is not a valid string: %v", createData)+ }++ // Get by id+ getResp, err := TestConfig.GetJSON(fmt.Sprintf("/datasets/%s", datasetID), nil, nil)+ if err != nil {+ t.Fatalf("get dataset request failed: %v", err)+ }+ getPayload := requireStatusCode(t, getResp, http.StatusOK)+ requireCodeZero(t, getPayload)+ getData, ok := getPayload["data"].(map[string]interface{})+ if !ok || getData["id"] != datasetID {+ t.Fatalf("get response data.id mismatch: %v", getPayload)+ }++ // Update+ updateResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", datasetID), map[string]interface{}{"name": "restful_dataset_crud_updated"}, nil)+ if err != nil {+ t.Fatalf("update dataset request failed: %v", err)+ }+ updatePayload := requireStatusCode(t, updateResp, http.StatusOK)+ requireCodeZero(t, updatePayload)+ updateData, ok := updatePayload["data"].(map[string]interface{})+ if !ok || updateData["name"] != "restful_dataset_crud_updated" {+ t.Fatalf("update response data.name mismatch: %v", updatePayload)+ }++ // List with id filter+ listResp, err := TestConfig.GetJSON("/datasets", map[string]interface{}{"id": datasetID}, nil)+ if err != nil {+ t.Fatalf("list dataset request failed: %v", err)+ }+ listPayload := requireStatusCode(t, listResp, http.StatusOK)+ requireCodeZero(t, listPayload)+ listData, ok := listPayload["data"].([]interface{})+ if !ok || len(listData) != 1 {+ t.Fatalf("expected 1 dataset in list, got %v", listPayload)+ }+ firstItem, ok := listData[0].(map[string]interface{})+ if !ok || firstItem["id"] != datasetID {+ t.Fatalf("list response data[0].id mismatch: %v", listPayload)+ }++ // Delete+ deleteResp, err := TestConfig.DeleteJSON("/datasets", map[string]interface{}{"ids": []interface{}{datasetID}}, nil)+ if err != nil {+ t.Fatalf("delete dataset request failed: %v", err)+ }+ deletePayload := requireStatusCode(t, deleteResp, http.StatusOK)+ requireCodeZero(t, deletePayload)++ // List after delete+ listAfterResp, err := TestConfig.GetJSON("/datasets", nil, nil)+ if err != nil {+ t.Fatalf("list after delete request failed: %v", err)+ }+ listAfterPayload := requireStatusCode(t, listAfterResp, http.StatusOK)+ requireCodeZero(t, listAfterPayload)+ listAfterData, ok := listAfterPayload["data"].([]interface{})+ if !ok {+ t.Fatalf("list after delete data is not an array: %v", listAfterPayload)+ }+ for _, item := range listAfterData {+ dataset, ok := item.(map[string]interface{})+ if !ok {+ continue+ }+ if dataset["id"] == datasetID {+ t.Fatalf("deleted dataset %s still present in list: %v", datasetID, listAfterPayload)+ }+ }+}++func TestDatasetUpdateNameAndCaseInsensitiveContract(t *testing.T) {+ clearDatasets(t)++ // Create first dataset+ firstResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": "dataset_update_name_source"}, nil)+ if err != nil {+ t.Fatalf("create first dataset request failed: %v", err)+ }+ firstPayload := requireStatusCode(t, firstResp, http.StatusOK)+ requireCodeZero(t, firstPayload)+ firstData, ok := firstPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("first response data is not an object: %v", firstPayload)+ }+ firstDatasetID, ok := firstData["id"].(string)+ if !ok || firstDatasetID == "" {+ t.Fatalf("first dataset id is invalid: %v", firstData)+ }++ // Create second dataset+ secondResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": "dataset_update_name_target"}, nil)+ if err != nil {+ t.Fatalf("create second dataset request failed: %v", err)+ }+ secondPayload := requireStatusCode(t, secondResp, http.StatusOK)+ requireCodeZero(t, secondPayload)+ secondData, ok := secondPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("second response data is not an object: %v", secondPayload)+ }+ secondDatasetName, ok := secondData["name"].(string)+ if !ok || secondDatasetName == "" {+ t.Fatalf("second dataset name is invalid: %v", secondData)+ }++ // Rename first dataset+ renameResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", firstDatasetID), map[string]interface{}{"name": "dataset_update_name_renamed"}, nil)+ if err != nil {+ t.Fatalf("rename dataset request failed: %v", err)+ }+ renamePayload := requireStatusCode(t, renameResp, http.StatusOK)+ requireCodeZero(t, renamePayload)+ renameData, ok := renamePayload["data"].(map[string]interface{})+ if !ok || renameData["name"] != "dataset_update_name_renamed" {+ t.Fatalf("rename response data.name mismatch: %v", renamePayload)+ }++ // List with id filter+ listResp, err := TestConfig.GetJSON("/datasets", map[string]interface{}{"id": firstDatasetID}, nil)+ if err != nil {+ t.Fatalf("list dataset request failed: %v", err)+ }+ listPayload := requireStatusCode(t, listResp, http.StatusOK)+ requireCodeZero(t, listPayload)+ listData, ok := listPayload["data"].([]interface{})+ if !ok || len(listData) != 1 {+ t.Fatalf("expected 1 dataset in list, got %v", listPayload)+ }+ firstItem, ok := listData[0].(map[string]interface{})+ if !ok || firstItem["name"] != "dataset_update_name_renamed" {+ t.Fatalf("list response data[0].name mismatch: %v", listPayload)+ }++ // Try duplicate name (case-insensitive)+ duplicateResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", firstDatasetID), map[string]interface{}{"name": strings.ToUpper(secondDatasetName)}, nil)+ if err != nil {+ t.Fatalf("duplicate case rename request failed: %v", err)+ }+ duplicatePayload := requireStatusCode(t, duplicateResp, http.StatusOK)+ duplicateCode, ok := duplicatePayload["code"].(float64)+ if !ok || int(duplicateCode) != 102 {+ t.Fatalf("expected code 102 for duplicate case rename, got %v, payload: %v", duplicatePayload["code"], duplicatePayload)+ }+ duplicateMessage, _ := duplicatePayload["message"].(string)+ if !strings.Contains(duplicateMessage, "already exists") {+ t.Fatalf("expected message to contain 'already exists', got %q, payload: %v", duplicateMessage, duplicatePayload)+ }+}++func encodeAvatar() (string, error) {+ img := image.NewRGBA(image.Rectangle{+ Min: image.Point{X: 0, Y: 0},+ Max: image.Point{X: 100, Y: 100},+ })+ draw.Draw(img, img.Bounds(), &image.Uniform{color.RGBA{R: 0, G: 0, B: 255, A: 255}}, image.Point{}, draw.Src)+ var buf bytes.Buffer+ if err := png.Encode(&buf, img); err != nil {+ return "", err+ }+ encoded := base64.StdEncoding.EncodeToString(buf.Bytes())+ return fmt.Sprintf("data:image/png;base64,%s", encoded), nil+}++func TestDatasetUpdateLanguageConnectorsAvatarAndDescriptionContract(t *testing.T) {+ clearDatasets(t)++ createResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": "dataset_update_lang_connectors"}, nil)+ if err != nil {+ t.Fatalf("create dataset request failed: %v", err)+ }+ createPayload := requireStatusCode(t, createResp, http.StatusOK)+ requireCodeZero(t, createPayload)+ createData, ok := createPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("create response data is not an object: %v", createPayload)+ }+ datasetID, ok := createData["id"].(string)+ if !ok || datasetID == "" {+ t.Fatalf("dataset id is invalid: %v", createData)+ }++ avatarValue, err := encodeAvatar()+ if err != nil {+ t.Fatalf("failed to encode avatar: %v", err)+ }++ updateResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", datasetID), map[string]interface{}{+ "name": "dataset_update_lang_connectors",+ "description": "",+ "parser_id": "naive",+ "parse_type": 1,+ "language": "English",+ "connectors": []interface{}{},+ "avatar": avatarValue,+ }, nil)+ if err != nil {+ t.Fatalf("update dataset request failed: %v", err)+ }+ updatePayload := requireStatusCode(t, updateResp, http.StatusOK)+ requireCodeZero(t, updatePayload)+ updateData, ok := updatePayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("update response data is not an object: %v", updatePayload)+ }+ if updateData["language"] != "English" {+ t.Fatalf("language mismatch: expected English, got %v", updatePayload)+ }+ connectors, ok := updateData["connectors"].([]interface{})+ if !ok {+ t.Fatalf("connectors is not an array: %v", updatePayload)+ }+ if len(connectors) != 0 {+ t.Fatalf("connectors should be empty: %v", updatePayload)+ }+ if updateData["avatar"] != avatarValue {+ t.Fatalf("avatar mismatch: %v", updatePayload)+ }++ descriptionResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", datasetID), map[string]interface{}{"description": "description"}, nil)+ if err != nil {+ t.Fatalf("update description request failed: %v", err)+ }+ descriptionPayload := requireStatusCode(t, descriptionResp, http.StatusOK)+ requireCodeZero(t, descriptionPayload)+ descriptionData, ok := descriptionPayload["data"].(map[string]interface{})+ if !ok || descriptionData["description"] != "description" {+ t.Fatalf("description mismatch: %v", descriptionPayload)+ }+}++func TestDatasetUpdateParserConfigValidMatrixContract(t *testing.T) {+ clearDatasets(t)+ t.Skip("Go validation or response contract does not match the established API contract")++ cases := []struct {+ name string+ parserConfig map[string]interface{}+ }{+ {name: "auto_keywords_min", parserConfig: map[string]interface{}{"auto_keywords": 0}},+ {name: "auto_keywords_mid", parserConfig: map[string]interface{}{"auto_keywords": 16}},+ {name: "auto_keywords_max", parserConfig: map[string]interface{}{"auto_keywords": 32}},+ {name: "auto_questions_min", parserConfig: map[string]interface{}{"auto_questions": 0}},+ {name: "auto_questions_mid", parserConfig: map[string]interface{}{"auto_questions": 5}},+ {name: "auto_questions_max", parserConfig: map[string]interface{}{"auto_questions": 10}},+ {name: "chunk_token_num_min", parserConfig: map[string]interface{}{"chunk_token_num": 1}},+ {name: "chunk_token_num_mid", parserConfig: map[string]interface{}{"chunk_token_num": 1024}},+ {name: "chunk_token_num_max", parserConfig: map[string]interface{}{"chunk_token_num": 2048}},+ {name: "delimiter", parserConfig: map[string]interface{}{"delimiter": "\n"}},+ {name: "delimiter_space", parserConfig: map[string]interface{}{"delimiter": " "}},+ {name: "html4excel_true", parserConfig: map[string]interface{}{"html4excel": true}},+ {name: "html4excel_false", parserConfig: map[string]interface{}{"html4excel": false}},+ {name: "layout_recognize_DeepDOC", parserConfig: map[string]interface{}{"layout_recognize": "DeepDOC"}},+ {name: "layout_recognize_navie", parserConfig: map[string]interface{}{"layout_recognize": "Plain Text"}},+ {name: "tag_kb_ids", parserConfig: map[string]interface{}{"tag_kb_ids": []interface{}{"1", "2"}}},+ {name: "topn_tags_min", parserConfig: map[string]interface{}{"topn_tags": 1}},+ {name: "topn_tags_mid", parserConfig: map[string]interface{}{"topn_tags": 5}},+ {name: "topn_tags_max", parserConfig: map[string]interface{}{"topn_tags": 10}},+ {name: "filename_embd_weight_min", parserConfig: map[string]interface{}{"filename_embd_weight": 0.1}},+ {name: "filename_embd_weight_mid", parserConfig: map[string]interface{}{"filename_embd_weight": 0.5}},+ {name: "filename_embd_weight_max", parserConfig: map[string]interface{}{"filename_embd_weight": 1.0}},+ {name: "task_page_size_min", parserConfig: map[string]interface{}{"task_page_size": 1}},+ {name: "task_page_size_None", parserConfig: map[string]interface{}{"task_page_size": nil}},+ {name: "pages", parserConfig: map[string]interface{}{"pages": []interface{}{[]interface{}{1, 100}}}},+ {name: "pages_none", parserConfig: map[string]interface{}{"pages": nil}},+ {name: "graphrag_true", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"use_graphrag": true}}},+ {name: "graphrag_false", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"use_graphrag": false}}},+ {name: "graphrag_entity_types", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"entity_types": []interface{}{"age", "sex", "height", "weight"}}}},+ {name: "graphrag_method_general", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"method": "general"}}},+ {name: "graphrag_method_light", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"method": "light"}}},+ {name: "graphrag_community_true", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"community": true}}},+ {name: "graphrag_community_false", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"community": false}}},+ {name: "graphrag_resolution_true", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"resolution": true}}},+ {name: "graphrag_resolution_false", parserConfig: map[string]interface{}{"graphrag": map[string]interface{}{"resolution": false}}},+ {name: "raptor_true", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"use_raptor": true}}},+ {name: "raptor_false", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"use_raptor": false}}},+ {name: "raptor_prompt", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"prompt": "Who are you?"}}},+ {name: "raptor_max_token_min", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_token": 512}}},+ {name: "raptor_max_token_mid", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_token": 1024}}},+ {name: "raptor_max_token_max", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_token": 2048}}},+ {name: "raptor_clustering_threshold_min", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"clustering_threshold": 0.0}}},+ {name: "raptor_clustering_threshold_mid", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"clustering_threshold": 0.5}}},+ {name: "raptor_clustering_threshold_max", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"clustering_threshold": 1.0}}},+ {name: "raptor_max_cluster_min", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_cluster": 1}}},+ {name: "raptor_max_cluster_mid", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_cluster": 512}}},+ {name: "raptor_max_cluster_max", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"max_cluster": 1024}}},+ {name: "raptor_random_seed_min", parserConfig: map[string]interface{}{"raptor": map[string]interface{}{"random_seed": 0}}},+ }++ for _, tc := range cases {+ tc := tc+ t.Run(tc.name, func(t *testing.T) {+ createResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": fmt.Sprintf("dataset_update_parser_%s", tc.name)}, nil)+ if err != nil {+ t.Fatalf("create dataset request failed: %v", err)+ }+ createPayload := requireStatusCode(t, createResp, http.StatusOK)+ requireCodeZero(t, createPayload)+ createData, ok := createPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("create response data is not an object: %v", createPayload)+ }+ datasetID, ok := createData["id"].(string)+ if !ok || datasetID == "" {+ t.Fatalf("dataset id is invalid: %v", createData)+ }++ updateResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", datasetID), map[string]interface{}{"parser_config": tc.parserConfig}, nil)+ if err != nil {+ t.Fatalf("update parser_config request failed: %v", err)+ }+ updatePayload := requireStatusCode(t, updateResp, http.StatusOK)+ requireCodeZero(t, updatePayload)++ listResp, err := TestConfig.GetJSON("/datasets", map[string]interface{}{"id": datasetID}, nil)+ if err != nil {+ t.Fatalf("list dataset request failed: %v", err)+ }+ listPayload := requireStatusCode(t, listResp, http.StatusOK)+ requireCodeZero(t, listPayload)+ listData, ok := listPayload["data"].([]interface{})+ if !ok || len(listData) != 1 {+ t.Fatalf("expected 1 dataset in list, got %v", listPayload)+ }+ firstItem, ok := listData[0].(map[string]interface{})+ if !ok {+ t.Fatalf("list data[0] is not an object: %v", listPayload)+ }+ actualParserConfig, ok := firstItem["parser_config"].(map[string]interface{})+ if !ok {+ t.Fatalf("parser_config is not an object: %v", firstItem)+ }++ for key, expectedValue := range tc.parserConfig {+ if key == "graphrag" || key == "raptor" {+ if _, exists := actualParserConfig[key]; exists {+ t.Fatalf("expected %s not in parser_config, but got %v", key, actualParserConfig)+ }+ continue+ }+ actualValue, ok := actualParserConfig[key]+ if !ok {+ t.Fatalf("parser_config missing key %s: %v", key, actualParserConfig)+ }+ if !jsonDeepEqual(actualValue, expectedValue) {+ t.Fatalf("parser_config.%s mismatch: expected %v, got %v", key, expectedValue, actualValue)+ }+ }+ })+ }+}++func TestDatasetUpdateParserConfigWithChunkMethodChangeContract(t *testing.T) {+ clearDatasets(t)++ cases := []struct {+ name string+ updatePayload map[string]interface{}+ }{+ {+ name: "parser_config_empty",+ updatePayload: map[string]interface{}{+ "parser_id": "qa",+ "parse_type": 1,+ "parser_config": map[string]interface{}{},+ },+ },+ {+ name: "parser_config_none",+ updatePayload: map[string]interface{}{+ "parser_id": "qa",+ "parse_type": 1,+ "parser_config": nil,+ },+ },+ {+ name: "parser_config_unset",+ updatePayload: map[string]interface{}{+ "parser_id": "qa",+ "parse_type": 1,+ },+ },+ }++ for _, tc := range cases {+ tc := tc+ t.Run(tc.name, func(t *testing.T) {+ createResp, err := TestConfig.PostJSON("/datasets", map[string]interface{}{"name": fmt.Sprintf("dataset_update_%s", tc.name)}, nil)+ if err != nil {+ t.Fatalf("create dataset request failed: %v", err)+ }+ createPayload := requireStatusCode(t, createResp, http.StatusOK)+ requireCodeZero(t, createPayload)+ createData, ok := createPayload["data"].(map[string]interface{})+ if !ok {+ t.Fatalf("create response data is not an object: %v", createPayload)+ }+ datasetID, ok := createData["id"].(string)+ if !ok || datasetID == "" {+ t.Fatalf("dataset id is invalid: %v", createData)+ }++ updateResp, err := TestConfig.PutJSON(fmt.Sprintf("/datasets/%s", datasetID), tc.updatePayload, nil)+ if err != nil {+ t.Fatalf("update dataset request failed: %v", err)+ }+ updatePayload := requireStatusCode(t, updateResp, http.StatusOK)+ requireCodeZero(t, updatePayload)++ listResp, err := TestConfig.GetJSON("/datasets", map[string]interface{}{"id": datasetID}, nil)+ if err != nil {+ t.Fatalf("list dataset request failed: %v", err)+ }+ listPayload := requireStatusCode(t, listResp, http.StatusOK)+ requireCodeZero(t, listPayload)+ listData, ok := listPayload["data"].([]interface{})+ if !ok || len(listData) != 1 {+ t.Fatalf("expected 1 dataset in list, got %v", listPayload)+ }+ firstItem, ok := listData[0].(map[string]interface{})+ if !ok {+ t.Fatalf("list data[0] is not an object: %v", listPayload)+ }+ actualParserConfig, ok := firstItem["parser_config"].(map[string]interface{})+ if !ok || len(actualParserConfig) == 0 {+ t.Fatalf("parser_config should be non-empty map: %v", firstItem)+ }+ if _, exists := actualParserConfig["raptor"]; exists {+ t.Fatalf("raptor should not be in parser_config: %v", actualParserConfig)+ }+ if _, exists := actualParserConfig["graphrag"]; exists {+ t.Fatalf("graphrag should not be in parser_config: %v", actualParserConfig)+ }+ })+ }+}diff --git a/test/api/main_test.go b/test/api/main_test.gonew file mode 100644index 0000000000..9654df23a7--- /dev/null+++ b/test/api/main_test.go@@ -0,0 +1,47 @@+//go:build integration++//+// 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 api++import (+ "fmt"+ "os"+ "testing"+)++func TestMain(m *testing.M) {+ fmt.Fprintln(os.Stderr, "Login")++ err := TestConfig.Login()+ if err != nil {+ fmt.Fprintf(os.Stderr, "Failed to login: %v\n", err)+ os.Exit(1)+ }++ // Run the test cases+ code := m.Run()++ err = TestConfig.Logout()+ if err != nil {+ fmt.Fprintf(os.Stderr, "Failed to logout: %v\n", err)+ os.Exit(1)+ }++ fmt.Fprintln(os.Stderr, "Logout")+ os.Exit(code)+}diff --git a/test/api/user_api_test.go b/test/api/user_api_test.gonew file mode 100644index 0000000000..e410a21a5f--- /dev/null+++ b/test/api/user_api_test.go@@ -0,0 +1,30 @@+//go:build integration++//+// 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 api++import (+ "testing"+)++func TestCreateUser(t *testing.T) {+ //resp, err := http.Post(baseURL+"/users", "application/json", body)+ //assert.NoError(t, err)+ //assert.Equal(t, 201, resp.StatusCode)+ t.Log("TestCreateUser")+}