pengjunjie/ragflow
1
0
Fork 1
mirror of https://github.com/infiniflow/ragflow.git synced 2025-12-08 20:42:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix: document typo in test (#8091)

Browse Source 
### What problem does this PR solve?

fix document typo in test

### Type of change

- [x] Typo
This commit is contained in:
Liu An
2025-06-05 19:03:46 +08:00
committed by GitHub
parent f007c1c772
commit 92625e1ca9
15 changed files with 178 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
test/testcases/test_http_api/common.py
View File

@ -68,7 +68,7 @@ def batch_create_datasets(auth, num):
# FILE MANAGEMENT WITHIN DATASET
def upload_documnets(auth, dataset_id, files_path=None):
def upload_documents(auth, dataset_id, files_path=None):
url = f"{HOST_ADDRESS}{FILE_API_URL}".format(dataset_id=dataset_id)
if files_path is None:
@ -110,31 +110,31 @@ def download_document(auth, dataset_id, document_id, save_path):
return res
def list_documnets(auth, dataset_id, params=None):
def list_documents(auth, dataset_id, params=None):
url = f"{HOST_ADDRESS}{FILE_API_URL}".format(dataset_id=dataset_id)
res = requests.get(url=url, headers=HEADERS, auth=auth, params=params)
return res.json()
def update_documnet(auth, dataset_id, document_id, payload=None):
def update_document(auth, dataset_id, document_id, payload=None):
url = f"{HOST_ADDRESS}{FILE_API_URL}/{document_id}".format(dataset_id=dataset_id)
res = requests.put(url=url, headers=HEADERS, auth=auth, json=payload)
return res.json()
def delete_documnets(auth, dataset_id, payload=None):
def delete_documents(auth, dataset_id, payload=None):
url = f"{HOST_ADDRESS}{FILE_API_URL}".format(dataset_id=dataset_id)
res = requests.delete(url=url, headers=HEADERS, auth=auth, json=payload)
return res.json()
def parse_documnets(auth, dataset_id, payload=None):
def parse_documents(auth, dataset_id, payload=None):
url = f"{HOST_ADDRESS}{FILE_CHUNK_API_URL}".format(dataset_id=dataset_id)
res = requests.post(url=url, headers=HEADERS, auth=auth, json=payload)
return res.json()
def stop_parse_documnets(auth, dataset_id, payload=None):
def stop_parse_documents(auth, dataset_id, payload=None):
url = f"{HOST_ADDRESS}{FILE_CHUNK_API_URL}".format(dataset_id=dataset_id)
res = requests.delete(url=url, headers=HEADERS, auth=auth, json=payload)
return res.json()
@ -145,7 +145,7 @@ def bulk_upload_documents(auth, dataset_id, num, tmp_path):
for i in range(num):
fp = create_txt_file(tmp_path / f"ragflow_test_upload_{i}.txt")
fps.append(fp)
res = upload_documnets(auth, dataset_id, fps)
res = upload_documents(auth, dataset_id, fps)
document_ids = []
for document in res["data"]:
document_ids.append(document["id"])

68
test/testcases/test_http_api/conftest.py
View File

@ -23,8 +23,8 @@ from common import (
delete_chat_assistants,
delete_datasets,
delete_session_with_chat_assistants,
list_documnets,
parse_documnets,
list_documents,
parse_documents,
)
from libs.auth import RAGFlowHttpApiAuth
from utils import wait_for
@ -44,13 +44,42 @@ from utils.file_utils import (
@wait_for(30, 1, "Document parsing timeout")
def condition(_auth, _dataset_id):
res = list_documnets(_auth, _dataset_id)
res = list_documents(_auth, _dataset_id)
for doc in res["data"]["docs"]:
if doc["run"] != "DONE":
return False
return True
@pytest.fixture
def generate_test_files(request, tmp_path):
file_creators = {
"docx": (tmp_path / "ragflow_test.docx", create_docx_file),
"excel": (tmp_path / "ragflow_test.xlsx", create_excel_file),
"ppt": (tmp_path / "ragflow_test.pptx", create_ppt_file),
"image": (tmp_path / "ragflow_test.png", create_image_file),
"pdf": (tmp_path / "ragflow_test.pdf", create_pdf_file),
"txt": (tmp_path / "ragflow_test.txt", create_txt_file),
"md": (tmp_path / "ragflow_test.md", create_md_file),
"json": (tmp_path / "ragflow_test.json", create_json_file),
"eml": (tmp_path / "ragflow_test.eml", create_eml_file),
"html": (tmp_path / "ragflow_test.html", create_html_file),
}
files = {}
for file_type, (file_path, creator_func) in file_creators.items():
if request.param in ["", file_type]:
creator_func(file_path)
files[file_type] = file_path
return files
@pytest.fixture(scope="class")
def ragflow_tmp_dir(request, tmp_path_factory):
class_name = request.cls.__name__
return tmp_path_factory.mktemp(class_name)
@pytest.fixture(scope="session")
def api_key(token):
return RAGFlowHttpApiAuth(token)
@ -83,35 +112,6 @@ def clear_session_with_chat_assistants(request, api_key, add_chat_assistants):
request.addfinalizer(cleanup)
@pytest.fixture
def generate_test_files(request, tmp_path):
file_creators = {
"docx": (tmp_path / "ragflow_test.docx", create_docx_file),
"excel": (tmp_path / "ragflow_test.xlsx", create_excel_file),
"ppt": (tmp_path / "ragflow_test.pptx", create_ppt_file),
"image": (tmp_path / "ragflow_test.png", create_image_file),
"pdf": (tmp_path / "ragflow_test.pdf", create_pdf_file),
"txt": (tmp_path / "ragflow_test.txt", create_txt_file),
"md": (tmp_path / "ragflow_test.md", create_md_file),
"json": (tmp_path / "ragflow_test.json", create_json_file),
"eml": (tmp_path / "ragflow_test.eml", create_eml_file),
"html": (tmp_path / "ragflow_test.html", create_html_file),
}
files = {}
for file_type, (file_path, creator_func) in file_creators.items():
if request.param in ["", file_type]:
creator_func(file_path)
files[file_type] = file_path
return files
@pytest.fixture(scope="class")
def ragflow_tmp_dir(request, tmp_path_factory):
class_name = request.cls.__name__
return tmp_path_factory.mktemp(class_name)
@pytest.fixture(scope="class")
def add_dataset(request, api_key):
def cleanup():
@ -143,7 +143,7 @@ def add_document(api_key, add_dataset, ragflow_tmp_dir):
@pytest.fixture(scope="class")
def add_chunks(api_key, add_document):
dataset_id, document_id = add_document
parse_documnets(api_key, dataset_id, {"document_ids": [document_id]})
parse_documents(api_key, dataset_id, {"document_ids": [document_id]})
condition(api_key, dataset_id)
chunk_ids = []
@ -166,7 +166,7 @@ def add_chat_assistants(request, api_key, add_document):
request.addfinalizer(cleanup)
dataset_id, document_id = add_document
parse_documnets(api_key, dataset_id, {"document_ids": [document_id]})
parse_documents(api_key, dataset_id, {"document_ids": [document_id]})
condition(api_key, dataset_id)
chat_assistant_ids = []

6
test/testcases/test_http_api/test_chat_assistant_management/conftest.py
View File

@ -14,13 +14,13 @@
# limitations under the License.
#
import pytest
from common import create_chat_assistant, delete_chat_assistants, list_documnets, parse_documnets
from common import create_chat_assistant, delete_chat_assistants, list_documents, parse_documents
from utils import wait_for
@wait_for(30, 1, "Document parsing timeout")
def condition(_auth, _dataset_id):
res = list_documnets(_auth, _dataset_id)
res = list_documents(_auth, _dataset_id)
for doc in res["data"]["docs"]:
if doc["run"] != "DONE":
return False
@ -35,7 +35,7 @@ def add_chat_assistants_func(request, api_key, add_document):
request.addfinalizer(cleanup)
dataset_id, document_id = add_document
parse_documnets(api_key, dataset_id, {"document_ids": [document_id]})
parse_documents(api_key, dataset_id, {"document_ids": [document_id]})
condition(api_key, dataset_id)
chat_assistant_ids = []

6
test/testcases/test_http_api/test_chunk_management_within_dataset/conftest.py
View File

@ -16,13 +16,13 @@
import pytest
from common import add_chunk, delete_chunks, list_documnets, parse_documnets
from common import add_chunk, delete_chunks, list_documents, parse_documents
from utils import wait_for
@wait_for(30, 1, "Document parsing timeout")
def condition(_auth, _dataset_id):
res = list_documnets(_auth, _dataset_id)
res = list_documents(_auth, _dataset_id)
for doc in res["data"]["docs"]:
if doc["run"] != "DONE":
return False
@ -32,7 +32,7 @@ def condition(_auth, _dataset_id):
@pytest.fixture(scope="function")
def add_chunks_func(request, api_key, add_document):
dataset_id, document_id = add_document
parse_documnets(api_key, dataset_id, {"document_ids": [document_id]})
parse_documents(api_key, dataset_id, {"document_ids": [document_id]})
condition(api_key, dataset_id)
chunk_ids = []

4
test/testcases/test_http_api/test_chunk_management_within_dataset/test_add_chunk.py
View File

@ -16,7 +16,7 @@
from concurrent.futures import ThreadPoolExecutor
import pytest
from common import INVALID_API_TOKEN, add_chunk, delete_documnets, list_chunks
from common import INVALID_API_TOKEN, add_chunk, delete_documents, list_chunks
from libs.auth import RAGFlowHttpApiAuth
@ -217,7 +217,7 @@ class TestAddChunk:
@pytest.mark.p2
def test_add_chunk_to_deleted_document(self, api_key, add_document):
dataset_id, document_id = add_document
delete_documnets(api_key, dataset_id, {"ids": [document_id]})
delete_documents(api_key, dataset_id, {"ids": [document_id]})
res = add_chunk(api_key, dataset_id, document_id, {"content": "chunk test"})
assert res["code"] == 102
assert res["message"] == f"You don't own the document {document_id}."

4
test/testcases/test_http_api/test_chunk_management_within_dataset/test_update_chunk.py
View File

@ -18,7 +18,7 @@ from concurrent.futures import ThreadPoolExecutor
from random import randint
import pytest
from common import INVALID_API_TOKEN, delete_documnets, update_chunk
from common import INVALID_API_TOKEN, delete_documents, update_chunk
from libs.auth import RAGFlowHttpApiAuth
@ -240,7 +240,7 @@ class TestUpdatedChunk:
@pytest.mark.p3
def test_update_chunk_to_deleted_document(self, api_key, add_chunks):
dataset_id, document_id, chunk_ids = add_chunks
delete_documnets(api_key, dataset_id, {"ids": [document_id]})
delete_documents(api_key, dataset_id, {"ids": [document_id]})
res = update_chunk(api_key, dataset_id, document_id, chunk_ids[0])
assert res["code"] == 102
assert res["message"] == f"Can't find this chunk {chunk_ids[0]}"

12
test/testcases/test_http_api/test_file_management_within_dataset/conftest.py
View File

@ -16,7 +16,7 @@
import pytest
from common import bulk_upload_documents, delete_documnets
from common import bulk_upload_documents, delete_documents
@pytest.fixture(scope="function")
@ -25,7 +25,7 @@ def add_document_func(request, api_key, add_dataset, ragflow_tmp_dir):
document_ids = bulk_upload_documents(api_key, dataset_id, 1, ragflow_tmp_dir)
def cleanup():
delete_documnets(api_key, dataset_id, {"ids": document_ids})
delete_documents(api_key, dataset_id, {"ids": document_ids})
request.addfinalizer(cleanup)
return dataset_id, document_ids[0]
@ -37,15 +37,19 @@ def add_documents(request, api_key, add_dataset, ragflow_tmp_dir):
document_ids = bulk_upload_documents(api_key, dataset_id, 5, ragflow_tmp_dir)
def cleanup():
delete_documnets(api_key, dataset_id, {"ids": document_ids})
delete_documents(api_key, dataset_id, {"ids": document_ids})
request.addfinalizer(cleanup)
return dataset_id, document_ids
@pytest.fixture(scope="function")
def add_documents_func(api_key, add_dataset_func, ragflow_tmp_dir):
def add_documents_func(request, api_key, add_dataset_func, ragflow_tmp_dir):
dataset_id = add_dataset_func
document_ids = bulk_upload_documents(api_key, dataset_id, 3, ragflow_tmp_dir)
def cleanup():
delete_documents(api_key, dataset_id, {"ids": document_ids})
request.addfinalizer(cleanup)
return dataset_id, document_ids

42
test/testcases/test_http_api/test_file_management_within_dataset/test_delete_documents.py
View File

@ -16,7 +16,7 @@
from concurrent.futures import ThreadPoolExecutor
import pytest
from common import INVALID_API_TOKEN, bulk_upload_documents, delete_documnets, list_documnets
from common import INVALID_API_TOKEN, bulk_upload_documents, delete_documents, list_documents
from libs.auth import RAGFlowHttpApiAuth
@ -34,7 +34,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = delete_documnets(invalid_auth, "dataset_id")
res = delete_documents(invalid_auth, "dataset_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -75,12 +75,12 @@ class TestDocumentsDeletion:
dataset_id, document_ids = add_documents_func
if callable(payload):
payload = payload(document_ids)
res = delete_documnets(api_key, dataset_id, payload)
res = delete_documents(api_key, dataset_id, payload)
assert res["code"] == expected_code
if res["code"] != 0:
assert res["message"] == expected_message
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert len(res["data"]["docs"]) == remaining
assert res["data"]["total"] == remaining
@ -98,7 +98,7 @@ class TestDocumentsDeletion:
)
def test_invalid_dataset_id(self, api_key, add_documents_func, dataset_id, expected_code, expected_message):
_, document_ids = add_documents_func
res = delete_documnets(api_key, dataset_id, {"ids": document_ids[:1]})
res = delete_documents(api_key, dataset_id, {"ids": document_ids[:1]})
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -115,52 +115,52 @@ class TestDocumentsDeletion:
dataset_id, document_ids = add_documents_func
if callable(payload):
payload = payload(document_ids)
res = delete_documnets(api_key, dataset_id, payload)
res = delete_documents(api_key, dataset_id, payload)
assert res["code"] == 102
assert res["message"] == "Documents not found: ['invalid_id']"
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert len(res["data"]["docs"]) == 0
assert res["data"]["total"] == 0
@pytest.mark.p2
def test_repeated_deletion(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
res = delete_documnets(api_key, dataset_id, {"ids": document_ids})
res = delete_documents(api_key, dataset_id, {"ids": document_ids})
assert res["code"] == 0
res = delete_documnets(api_key, dataset_id, {"ids": document_ids})
res = delete_documents(api_key, dataset_id, {"ids": document_ids})
assert res["code"] == 102
assert "Documents not found" in res["message"]
@pytest.mark.p2
def test_duplicate_deletion(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
res = delete_documnets(api_key, dataset_id, {"ids": document_ids + document_ids})
res = delete_documents(api_key, dataset_id, {"ids": document_ids + document_ids})
assert res["code"] == 0
assert "Duplicate document ids" in res["data"]["errors"][0]
assert res["data"]["success_count"] == 3
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert len(res["data"]["docs"]) == 0
assert res["data"]["total"] == 0
@pytest.mark.p3
def test_concurrent_deletion(api_key, add_dataset, tmp_path):
documnets_num = 100
documents_num = 100
dataset_id = add_dataset
document_ids = bulk_upload_documents(api_key, dataset_id, documnets_num, tmp_path)
document_ids = bulk_upload_documents(api_key, dataset_id, documents_num, tmp_path)
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [
executor.submit(
delete_documnets,
delete_documents,
api_key,
dataset_id,
{"ids": document_ids[i : i + 1]},
)
for i in range(documnets_num)
for i in range(documents_num)
]
responses = [f.result() for f in futures]
assert all(r["code"] == 0 for r in responses)
@ -168,14 +168,14 @@ def test_concurrent_deletion(api_key, add_dataset, tmp_path):
@pytest.mark.p3
def test_delete_1k(api_key, add_dataset, tmp_path):
documnets_num = 1_000
documents_num = 1_000
dataset_id = add_dataset
document_ids = bulk_upload_documents(api_key, dataset_id, documnets_num, tmp_path)
res = list_documnets(api_key, dataset_id)
assert res["data"]["total"] == documnets_num
document_ids = bulk_upload_documents(api_key, dataset_id, documents_num, tmp_path)
res = list_documents(api_key, dataset_id)
assert res["data"]["total"] == documents_num
res = delete_documnets(api_key, dataset_id, {"ids": document_ids})
res = delete_documents(api_key, dataset_id, {"ids": document_ids})
assert res["code"] == 0
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert res["data"]["total"] == 0

18
test/testcases/test_http_api/test_file_management_within_dataset/test_download_document.py
View File

@ -15,10 +15,10 @@
#
import json
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import ThreadPoolExecutor, as_completed
import pytest
from common import INVALID_API_TOKEN, bulk_upload_documents, download_document, upload_documnets
from common import INVALID_API_TOKEN, bulk_upload_documents, download_document, upload_documents
from libs.auth import RAGFlowHttpApiAuth
from requests import codes
from utils import compare_by_hash
@ -66,7 +66,7 @@ class TestAuthorization:
def test_file_type_validation(api_key, add_dataset, generate_test_files, request):
dataset_id = add_dataset
fp = generate_test_files[request.node.callspec.params["generate_test_files"]]
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
document_id = res["data"][0]["id"]
res = download_document(
@ -154,9 +154,9 @@ class TestDocumentDownload:
@pytest.mark.p3
def test_concurrent_download(api_key, add_dataset, tmp_path):
document_count = 20
count = 20
dataset_id = add_dataset
document_ids = bulk_upload_documents(api_key, dataset_id, document_count, tmp_path)
document_ids = bulk_upload_documents(api_key, dataset_id, count, tmp_path)
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [
@ -167,11 +167,11 @@ def test_concurrent_download(api_key, add_dataset, tmp_path):
document_ids[i],
tmp_path / f"ragflow_test_download_{i}.txt",
)
for i in range(document_count)
for i in range(count)
]
responses = [f.result() for f in futures]
assert all(r.status_code == codes.ok for r in responses)
for i in range(document_count):
responses = list(as_completed(futures))
assert len(responses) == count, responses
for i in range(count):
assert compare_by_hash(
tmp_path / f"ragflow_test_upload_{i}.txt",
tmp_path / f"ragflow_test_download_{i}.txt",

28
test/testcases/test_http_api/test_file_management_within_dataset/test_list_documents.py
View File

@ -16,7 +16,7 @@
from concurrent.futures import ThreadPoolExecutor
import pytest
from common import INVALID_API_TOKEN, list_documnets
from common import INVALID_API_TOKEN, list_documents
from libs.auth import RAGFlowHttpApiAuth
from utils import is_sorted
@ -35,7 +35,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = list_documnets(invalid_auth, "dataset_id")
res = list_documents(invalid_auth, "dataset_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -44,7 +44,7 @@ class TestDocumentsList:
@pytest.mark.p1
def test_default(self, api_key, add_documents):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert res["code"] == 0
assert len(res["data"]["docs"]) == 5
assert res["data"]["total"] == 5
@ -62,7 +62,7 @@ class TestDocumentsList:
],
)
def test_invalid_dataset_id(self, api_key, dataset_id, expected_code, expected_message):
res = list_documnets(api_key, dataset_id)
res = list_documents(api_key, dataset_id)
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -101,7 +101,7 @@ class TestDocumentsList:
expected_message,
):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
assert len(res["data"]["docs"]) == expected_page_size
@ -144,7 +144,7 @@ class TestDocumentsList:
expected_message,
):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
assert len(res["data"]["docs"]) == expected_page_size
@ -172,7 +172,7 @@ class TestDocumentsList:
expected_message,
):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
if callable(assertions):
@ -205,7 +205,7 @@ class TestDocumentsList:
expected_message,
):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
if callable(assertions):
@ -226,7 +226,7 @@ class TestDocumentsList:
)
def test_keywords(self, api_key, add_documents, params, expected_num):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == 0
assert len(res["data"]["docs"]) == expected_num
assert res["data"]["total"] == expected_num
@ -256,7 +256,7 @@ class TestDocumentsList:
expected_message,
):
dataset_id, _ = add_documents
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
if params["name"] in [None, ""]:
@ -290,7 +290,7 @@ class TestDocumentsList:
params = {"id": document_id(document_ids)}
else:
params = {"id": document_id}
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == expected_code
if expected_code == 0:
@ -333,7 +333,7 @@ class TestDocumentsList:
else:
params = {"id": document_id, "name": name}
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
if expected_code == 0:
assert len(res["data"]["docs"]) == expected_num
else:
@ -344,7 +344,7 @@ class TestDocumentsList:
dataset_id, _ = add_documents
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [executor.submit(list_documnets, api_key, dataset_id) for i in range(100)]
futures = [executor.submit(list_documents, api_key, dataset_id) for i in range(100)]
responses = [f.result() for f in futures]
assert all(r["code"] == 0 for r in responses)
@ -352,6 +352,6 @@ class TestDocumentsList:
def test_invalid_params(self, api_key, add_documents):
dataset_id, _ = add_documents
params = {"a": "b"}
res = list_documnets(api_key, dataset_id, params=params)
res = list_documents(api_key, dataset_id, params=params)
assert res["code"] == 0
assert len(res["data"]["docs"]) == 5

28
test/testcases/test_http_api/test_file_management_within_dataset/test_parse_documents.py
View File

@ -16,14 +16,14 @@
from concurrent.futures import ThreadPoolExecutor
import pytest
from common import INVALID_API_TOKEN, bulk_upload_documents, list_documnets, parse_documnets
from common import INVALID_API_TOKEN, bulk_upload_documents, list_documents, parse_documents
from libs.auth import RAGFlowHttpApiAuth
from utils import wait_for
@wait_for(30, 1, "Document parsing timeout")
def condition(_auth, _dataset_id, _document_ids=None):
res = list_documnets(_auth, _dataset_id)
res = list_documents(_auth, _dataset_id)
target_docs = res["data"]["docs"]
if _document_ids is None:
@ -42,7 +42,7 @@ def condition(_auth, _dataset_id, _document_ids=None):
def validate_document_details(auth, dataset_id, document_ids):
for document_id in document_ids:
res = list_documnets(auth, dataset_id, params={"id": document_id})
res = list_documents(auth, dataset_id, params={"id": document_id})
doc = res["data"]["docs"][0]
assert doc["run"] == "DONE"
assert len(doc["process_begin_at"]) > 0
@ -65,7 +65,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = parse_documnets(invalid_auth, "dataset_id")
res = parse_documents(invalid_auth, "dataset_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -87,7 +87,7 @@ class TestDocumentsParse:
dataset_id, document_ids = add_documents_func
if callable(payload):
payload = payload(document_ids)
res = parse_documnets(api_key, dataset_id, payload)
res = parse_documents(api_key, dataset_id, payload)
assert res["code"] == expected_code
if expected_code != 0:
assert res["message"] == expected_message
@ -116,7 +116,7 @@ class TestDocumentsParse:
expected_message,
):
_, document_ids = add_documents_func
res = parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -132,7 +132,7 @@ class TestDocumentsParse:
dataset_id, document_ids = add_documents_func
if callable(payload):
payload = payload(document_ids)
res = parse_documnets(api_key, dataset_id, payload)
res = parse_documents(api_key, dataset_id, payload)
assert res["code"] == 102
assert res["message"] == "Documents not found: ['invalid_id']"
@ -143,18 +143,18 @@ class TestDocumentsParse:
@pytest.mark.p3
def test_repeated_parse(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
res = parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 0
condition(api_key, dataset_id)
res = parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 0
@pytest.mark.p3
def test_duplicate_parse(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
res = parse_documnets(api_key, dataset_id, {"document_ids": document_ids + document_ids})
res = parse_documents(api_key, dataset_id, {"document_ids": document_ids + document_ids})
assert res["code"] == 0
assert "Duplicate document ids" in res["data"]["errors"][0]
assert res["data"]["success_count"] == 3
@ -168,7 +168,7 @@ class TestDocumentsParse:
def test_parse_100_files(api_key, add_dataset_func, tmp_path):
@wait_for(100, 1, "Document parsing timeout")
def condition(_auth, _dataset_id, _document_num):
res = list_documnets(_auth, _dataset_id, {"page_size": _document_num})
res = list_documents(_auth, _dataset_id, {"page_size": _document_num})
for doc in res["data"]["docs"]:
if doc["run"] != "DONE":
return False
@ -177,7 +177,7 @@ def test_parse_100_files(api_key, add_dataset_func, tmp_path):
document_num = 100
dataset_id = add_dataset_func
document_ids = bulk_upload_documents(api_key, dataset_id, document_num, tmp_path)
res = parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 0
condition(api_key, dataset_id, document_num)
@ -189,7 +189,7 @@ def test_parse_100_files(api_key, add_dataset_func, tmp_path):
def test_concurrent_parse(api_key, add_dataset_func, tmp_path):
@wait_for(120, 1, "Document parsing timeout")
def condition(_auth, _dataset_id, _document_num):
res = list_documnets(_auth, _dataset_id, {"page_size": _document_num})
res = list_documents(_auth, _dataset_id, {"page_size": _document_num})
for doc in res["data"]["docs"]:
if doc["run"] != "DONE":
return False
@ -202,7 +202,7 @@ def test_concurrent_parse(api_key, add_dataset_func, tmp_path):
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [
executor.submit(
parse_documnets,
parse_documents,
api_key,
dataset_id,
{"document_ids": document_ids[i : i + 1]},

40
test/testcases/test_http_api/test_file_management_within_dataset/test_stop_parse_documents.py
View File

@ -17,14 +17,14 @@ from concurrent.futures import ThreadPoolExecutor
from time import sleep
import pytest
from common import INVALID_API_TOKEN, bulk_upload_documents, list_documnets, parse_documnets, stop_parse_documnets
from common import INVALID_API_TOKEN, bulk_upload_documents, list_documents, parse_documents, stop_parse_documents
from libs.auth import RAGFlowHttpApiAuth
from utils import wait_for
def validate_document_parse_done(auth, dataset_id, document_ids):
for document_id in document_ids:
res = list_documnets(auth, dataset_id, params={"id": document_id})
res = list_documents(auth, dataset_id, params={"id": document_id})
doc = res["data"]["docs"][0]
assert doc["run"] == "DONE"
assert len(doc["process_begin_at"]) > 0
@ -35,7 +35,7 @@ def validate_document_parse_done(auth, dataset_id, document_ids):
def validate_document_parse_cancel(auth, dataset_id, document_ids):
for document_id in document_ids:
res = list_documnets(auth, dataset_id, params={"id": document_id})
res = list_documents(auth, dataset_id, params={"id": document_id})
doc = res["data"]["docs"][0]
assert doc["run"] == "CANCEL"
assert len(doc["process_begin_at"]) > 0
@ -56,7 +56,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = stop_parse_documnets(invalid_auth, "dataset_id")
res = stop_parse_documents(invalid_auth, "dataset_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -79,18 +79,18 @@ class TestDocumentsParseStop:
@wait_for(10, 1, "Document parsing timeout")
def condition(_auth, _dataset_id, _document_ids):
for _document_id in _document_ids:
res = list_documnets(_auth, _dataset_id, {"id": _document_id})
res = list_documents(_auth, _dataset_id, {"id": _document_id})
if res["data"]["docs"][0]["run"] != "DONE":
return False
return True
dataset_id, document_ids = add_documents_func
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
if callable(payload):
payload = payload(document_ids)
res = stop_parse_documnets(api_key, dataset_id, payload)
res = stop_parse_documents(api_key, dataset_id, payload)
assert res["code"] == expected_code
if expected_code != 0:
assert res["message"] == expected_message
@ -121,8 +121,8 @@ class TestDocumentsParseStop:
expected_message,
):
dataset_id, document_ids = add_documents_func
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documnets(api_key, invalid_dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documents(api_key, invalid_dataset_id, {"document_ids": document_ids})
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -137,11 +137,11 @@ class TestDocumentsParseStop:
)
def test_stop_parse_partial_invalid_document_id(self, api_key, add_documents_func, payload):
dataset_id, document_ids = add_documents_func
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
if callable(payload):
payload = payload(document_ids)
res = stop_parse_documnets(api_key, dataset_id, payload)
res = stop_parse_documents(api_key, dataset_id, payload)
assert res["code"] == 102
assert res["message"] == "You don't own the document invalid_id."
@ -150,19 +150,19 @@ class TestDocumentsParseStop:
@pytest.mark.p3
def test_repeated_stop_parse(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 0
res = stop_parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 102
assert res["message"] == "Can't stop parsing document with progress at 0 or 1"
@pytest.mark.p3
def test_duplicate_stop_parse(self, api_key, add_documents_func):
dataset_id, document_ids = add_documents_func
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documnets(api_key, dataset_id, {"document_ids": document_ids + document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documents(api_key, dataset_id, {"document_ids": document_ids + document_ids})
assert res["code"] == 0
assert res["data"]["success_count"] == 3
assert f"Duplicate document ids: {document_ids[0]}" in res["data"]["errors"]
@ -173,9 +173,9 @@ def test_stop_parse_100_files(api_key, add_dataset_func, tmp_path):
document_num = 100
dataset_id = add_dataset_func
document_ids = bulk_upload_documents(api_key, dataset_id, document_num, tmp_path)
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
sleep(1)
res = stop_parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
res = stop_parse_documents(api_key, dataset_id, {"document_ids": document_ids})
assert res["code"] == 0
validate_document_parse_cancel(api_key, dataset_id, document_ids)
@ -185,12 +185,12 @@ def test_concurrent_parse(api_key, add_dataset_func, tmp_path):
document_num = 50
dataset_id = add_dataset_func
document_ids = bulk_upload_documents(api_key, dataset_id, document_num, tmp_path)
parse_documnets(api_key, dataset_id, {"document_ids": document_ids})
parse_documents(api_key, dataset_id, {"document_ids": document_ids})
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [
executor.submit(
stop_parse_documnets,
stop_parse_documents,
api_key,
dataset_id,
{"document_ids": document_ids[i : i + 1]},

26
test/testcases/test_http_api/test_file_management_within_dataset/test_update_document.py
View File

@ -16,7 +16,7 @@
import pytest
from common import DOCUMENT_NAME_LIMIT, INVALID_API_TOKEN, list_documnets, update_documnet
from common import DOCUMENT_NAME_LIMIT, INVALID_API_TOKEN, list_documents, update_document
from libs.auth import RAGFlowHttpApiAuth
@ -34,7 +34,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = update_documnet(invalid_auth, "dataset_id", "document_id")
res = update_document(invalid_auth, "dataset_id", "document_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -84,10 +84,10 @@ class TestDocumentsUpdated:
)
def test_name(self, api_key, add_documents, name, expected_code, expected_message):
dataset_id, document_ids = add_documents
res = update_documnet(api_key, dataset_id, document_ids[0], {"name": name})
res = update_document(api_key, dataset_id, document_ids[0], {"name": name})
assert res["code"] == expected_code
if expected_code == 0:
res = list_documnets(api_key, dataset_id, {"id": document_ids[0]})
res = list_documents(api_key, dataset_id, {"id": document_ids[0]})
assert res["data"]["docs"][0]["name"] == name
else:
assert res["message"] == expected_message
@ -106,7 +106,7 @@ class TestDocumentsUpdated:
)
def test_invalid_document_id(self, api_key, add_documents, document_id, expected_code, expected_message):
dataset_id, _ = add_documents
res = update_documnet(api_key, dataset_id, document_id, {"name": "new_name.txt"})
res = update_document(api_key, dataset_id, document_id, {"name": "new_name.txt"})
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -124,7 +124,7 @@ class TestDocumentsUpdated:
)
def test_invalid_dataset_id(self, api_key, add_documents, dataset_id, expected_code, expected_message):
_, document_ids = add_documents
res = update_documnet(api_key, dataset_id, document_ids[0], {"name": "new_name.txt"})
res = update_document(api_key, dataset_id, document_ids[0], {"name": "new_name.txt"})
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -135,9 +135,9 @@ class TestDocumentsUpdated:
)
def test_meta_fields(self, api_key, add_documents, meta_fields, expected_code, expected_message):
dataset_id, document_ids = add_documents
res = update_documnet(api_key, dataset_id, document_ids[0], {"meta_fields": meta_fields})
res = update_document(api_key, dataset_id, document_ids[0], {"meta_fields": meta_fields})
if expected_code == 0:
res = list_documnets(api_key, dataset_id, {"id": document_ids[0]})
res = list_documents(api_key, dataset_id, {"id": document_ids[0]})
assert res["data"]["docs"][0]["meta_fields"] == meta_fields
else:
assert res["message"] == expected_message
@ -169,10 +169,10 @@ class TestDocumentsUpdated:
)
def test_chunk_method(self, api_key, add_documents, chunk_method, expected_code, expected_message):
dataset_id, document_ids = add_documents
res = update_documnet(api_key, dataset_id, document_ids[0], {"chunk_method": chunk_method})
res = update_document(api_key, dataset_id, document_ids[0], {"chunk_method": chunk_method})
assert res["code"] == expected_code
if expected_code == 0:
res = list_documnets(api_key, dataset_id, {"id": document_ids[0]})
res = list_documents(api_key, dataset_id, {"id": document_ids[0]})
if chunk_method != "":
assert res["data"]["docs"][0]["chunk_method"] == chunk_method
else:
@ -294,7 +294,7 @@ class TestDocumentsUpdated:
expected_message,
):
dataset_id, document_ids = add_documents
res = update_documnet(api_key, dataset_id, document_ids[0], payload)
res = update_document(api_key, dataset_id, document_ids[0], payload)
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -523,7 +523,7 @@ class TestUpdateDocumentParserConfig:
expected_message,
):
dataset_id, document_ids = add_documents
res = update_documnet(
res = update_document(
api_key,
dataset_id,
document_ids[0],
@ -531,7 +531,7 @@ class TestUpdateDocumentParserConfig:
)
assert res["code"] == expected_code
if expected_code == 0:
res = list_documnets(api_key, dataset_id, {"id": document_ids[0]})
res = list_documents(api_key, dataset_id, {"id": document_ids[0]})
if parser_config != {}:
for k, v in parser_config.items():
assert res["data"]["docs"][0]["parser_config"][k] == v

42
test/testcases/test_http_api/test_file_management_within_dataset/test_upload_documents.py
View File

@ -15,11 +15,11 @@
#
import string
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import ThreadPoolExecutor, as_completed
import pytest
import requests
from common import DOCUMENT_NAME_LIMIT, FILE_API_URL, HOST_ADDRESS, INVALID_API_TOKEN, list_datasets, upload_documnets
from common import DOCUMENT_NAME_LIMIT, FILE_API_URL, HOST_ADDRESS, INVALID_API_TOKEN, list_datasets, upload_documents
from libs.auth import RAGFlowHttpApiAuth
from requests_toolbelt import MultipartEncoder
from utils.file_utils import create_txt_file
@ -40,7 +40,7 @@ class TestAuthorization:
],
)
def test_invalid_auth(self, invalid_auth, expected_code, expected_message):
res = upload_documnets(invalid_auth, "dataset_id")
res = upload_documents(invalid_auth, "dataset_id")
assert res["code"] == expected_code
assert res["message"] == expected_message
@ -50,7 +50,7 @@ class TestDocumentsUpload:
def test_valid_single_upload(self, api_key, add_dataset_func, tmp_path):
dataset_id = add_dataset_func
fp = create_txt_file(tmp_path / "ragflow_test.txt")
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 0
assert res["data"][0]["dataset_id"] == dataset_id
assert res["data"][0]["name"] == fp.name
@ -75,7 +75,7 @@ class TestDocumentsUpload:
def test_file_type_validation(self, api_key, add_dataset_func, generate_test_files, request):
dataset_id = add_dataset_func
fp = generate_test_files[request.node.callspec.params["generate_test_files"]]
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 0
assert res["data"][0]["dataset_id"] == dataset_id
assert res["data"][0]["name"] == fp.name
@ -89,14 +89,14 @@ class TestDocumentsUpload:
dataset_id = add_dataset_func
fp = tmp_path / f"ragflow_test.{file_type}"
fp.touch()
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 500
assert res["message"] == f"ragflow_test.{file_type}: This type of file has not been supported yet!"
@pytest.mark.p2
def test_missing_file(self, api_key, add_dataset_func):
dataset_id = add_dataset_func
res = upload_documnets(api_key, dataset_id)
res = upload_documents(api_key, dataset_id)
assert res["code"] == 101
assert res["message"] == "No file part!"
@ -106,7 +106,7 @@ class TestDocumentsUpload:
fp = tmp_path / "empty.txt"
fp.touch()
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 0
assert res["data"][0]["size"] == 0
@ -131,14 +131,14 @@ class TestDocumentsUpload:
dataset_id = add_dataset_func
# filename_length = 129
fp = create_txt_file(tmp_path / f"{'a' * (DOCUMENT_NAME_LIMIT - 3)}.txt")
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 101
assert res["message"] == "File name should be less than 128 bytes."
@pytest.mark.p2
def test_invalid_dataset_id(self, api_key, tmp_path):
fp = create_txt_file(tmp_path / "ragflow_test.txt")
res = upload_documnets(api_key, "invalid_dataset_id", [fp])
res = upload_documents(api_key, "invalid_dataset_id", [fp])
assert res["code"] == 100
assert res["message"] == """LookupError("Can\'t find the dataset with ID invalid_dataset_id!")"""
@ -146,7 +146,7 @@ class TestDocumentsUpload:
def test_duplicate_files(self, api_key, add_dataset_func, tmp_path):
dataset_id = add_dataset_func
fp = create_txt_file(tmp_path / "ragflow_test.txt")
res = upload_documnets(api_key, dataset_id, [fp, fp])
res = upload_documents(api_key, dataset_id, [fp, fp])
assert res["code"] == 0
assert len(res["data"]) == 2
for i in range(len(res["data"])):
@ -160,8 +160,8 @@ class TestDocumentsUpload:
def test_same_file_repeat(self, api_key, add_dataset_func, tmp_path):
dataset_id = add_dataset_func
fp = create_txt_file(tmp_path / "ragflow_test.txt")
for i in range(10):
res = upload_documnets(api_key, dataset_id, [fp])
for i in range(3):
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 0
assert len(res["data"]) == 1
assert res["data"][0]["dataset_id"] == dataset_id
@ -179,7 +179,7 @@ class TestDocumentsUpload:
fp = tmp_path / f"{safe_filename}.txt"
fp.write_text("Sample text content")
res = upload_documnets(api_key, dataset_id, [fp])
res = upload_documents(api_key, dataset_id, [fp])
assert res["code"] == 0
assert len(res["data"]) == 1
assert res["data"][0]["dataset_id"] == dataset_id
@ -193,7 +193,7 @@ class TestDocumentsUpload:
for i in range(expected_document_count):
fp = create_txt_file(tmp_path / f"ragflow_test_{i}.txt")
fps.append(fp)
res = upload_documnets(api_key, dataset_id, fps)
res = upload_documents(api_key, dataset_id, fps)
assert res["code"] == 0
res = list_datasets(api_key, {"id": dataset_id})
@ -203,16 +203,16 @@ class TestDocumentsUpload:
def test_concurrent_upload(self, api_key, add_dataset_func, tmp_path):
dataset_id = add_dataset_func
expected_document_count = 20
count = 20
fps = []
for i in range(expected_document_count):
for i in range(count):
fp = create_txt_file(tmp_path / f"ragflow_test_{i}.txt")
fps.append(fp)
with ThreadPoolExecutor(max_workers=5) as executor:
futures = [executor.submit(upload_documnets, api_key, dataset_id, fps[i : i + 1]) for i in range(expected_document_count)]
responses = [f.result() for f in futures]
assert all(r["code"] == 0 for r in responses)
futures = [executor.submit(upload_documents, api_key, dataset_id, fps[i : i + 1]) for i in range(count)]
responses = list(as_completed(futures))
assert len(responses) == count, responses
res = list_datasets(api_key, {"id": dataset_id})
assert res["data"][0]["document_count"] == expected_document_count
assert res["data"][0]["document_count"] == count