集成测试¶

langchain_tests.integration_tests ¶

LangChain 组件的集成测试。

BaseStoreAsyncTests ¶

基类：BaseStandardTests, Generic[V]

用于检查 BaseStore 的键值 API 的测试套件。

此测试套件验证 BaseStore 的基本键值 API。

该测试套件专为同步键值存储设计。

实现者应继承此类测试套件，并提供一个为每个测试返回空键值存储的 fixture。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`kv_store`	获取要测试的键值存储类。
`three_values`	将在测试中使用的三个示例值。
`test_three_values`	测试 fixture 是否提供三个值。
`test_kv_store_is_empty`	测试键值存储是否为空。
`test_set_and_get_values`	测试在键值存储中设置和获取值。
`test_store_still_empty`	测试存储是否仍然为空。
`test_delete_values`	测试从键值存储中删除值。
`test_delete_bulk_values`	测试我们是否可以一次删除多个值。
`test_delete_missing_keys`	删除不存在的键不应引发异常。
`test_set_values_is_idempotent`	按键设置值应该是幂等的。
`test_get_can_get_same_value`	测试同一个值可以被多次检索。
`test_overwrite_values_by_key`	测试我们可以使用 mset 按键覆盖值。
`test_yield_keys`	测试我们可以从存储中生成键。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

kv_store `abstractmethod` `async` ¶

kv_store() -> BaseStore[str, V]

获取要测试的键值存储类。

返回的键值存储应为空。

three_values `abstractmethod` ¶

three_values() -> tuple[V, V, V]

将在测试中使用的三个示例值。

test_three_values `async` ¶

test_three_values(three_values: tuple[V, V, V]) -> None

测试 fixture 是否提供三个值。

test_kv_store_is_empty `async` ¶

test_kv_store_is_empty(kv_store: BaseStore[str, V]) -> None

测试键值存储是否为空。

test_set_and_get_values `async` ¶

test_set_and_get_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试在键值存储中设置和获取值。

test_store_still_empty `async` ¶

test_store_still_empty(kv_store: BaseStore[str, V]) -> None

测试存储是否仍然为空。

此测试应在设置值的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

test_delete_values `async` ¶

test_delete_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试从键值存储中删除值。

test_delete_bulk_values `async` ¶

test_delete_bulk_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试我们是否可以一次删除多个值。

test_delete_missing_keys `async` ¶

test_delete_missing_keys(kv_store: BaseStore[str, V]) -> None

删除不存在的键不应引发异常。

test_set_values_is_idempotent `async` ¶

test_set_values_is_idempotent(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

按键设置值应该是幂等的。

test_get_can_get_same_value `async` ¶

test_get_can_get_same_value(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试同一个值可以被多次检索。

test_overwrite_values_by_key `async` ¶

test_overwrite_values_by_key(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试我们可以使用 mset 按键覆盖值。

test_yield_keys `async` ¶

test_yield_keys(kv_store: BaseStore[str, V], three_values: tuple[V, V, V]) -> None

测试我们可以从存储中生成键。

BaseStoreSyncTests ¶

基类：BaseStandardTests, Generic[V]

用于检查 BaseStore 的键值 API 的测试套件。

此测试套件验证 BaseStore 的基本键值 API。

该测试套件专为同步键值存储设计。

实现者应继承此类测试套件，并提供一个为每个测试返回空键值存储的 fixture。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`kv_store`	获取要测试的键值存储类。
`three_values`	将在测试中使用的三个示例值。
`test_three_values`	测试 fixture 是否提供三个值。
`test_kv_store_is_empty`	测试键值存储是否为空。
`test_set_and_get_values`	测试在键值存储中设置和获取值。
`test_store_still_empty`	测试存储是否仍然为空。
`test_delete_values`	测试从键值存储中删除值。
`test_delete_bulk_values`	测试我们是否可以一次删除多个值。
`test_delete_missing_keys`	删除不存在的键不应引发异常。
`test_set_values_is_idempotent`	按键设置值应该是幂等的。
`test_get_can_get_same_value`	测试同一个值可以被多次检索。
`test_overwrite_values_by_key`	测试我们可以使用 mset 按键覆盖值。
`test_yield_keys`	测试我们可以从存储中生成键。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

kv_store `abstractmethod` ¶

kv_store() -> BaseStore[str, V]

获取要测试的键值存储类。

返回的键值存储应为空。

three_values `abstractmethod` ¶

three_values() -> tuple[V, V, V]

将在测试中使用的三个示例值。

test_three_values ¶

test_three_values(three_values: tuple[V, V, V]) -> None

测试 fixture 是否提供三个值。

test_kv_store_is_empty ¶

test_kv_store_is_empty(kv_store: BaseStore[str, V]) -> None

测试键值存储是否为空。

test_set_and_get_values ¶

test_set_and_get_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试在键值存储中设置和获取值。

test_store_still_empty ¶

test_store_still_empty(kv_store: BaseStore[str, V]) -> None

测试存储是否仍然为空。

此测试应在设置值的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

test_delete_values ¶

test_delete_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试从键值存储中删除值。

test_delete_bulk_values ¶

test_delete_bulk_values(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试我们是否可以一次删除多个值。

test_delete_missing_keys ¶

test_delete_missing_keys(kv_store: BaseStore[str, V]) -> None

删除不存在的键不应引发异常。

test_set_values_is_idempotent ¶

test_set_values_is_idempotent(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

按键设置值应该是幂等的。

test_get_can_get_same_value ¶

test_get_can_get_same_value(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试同一个值可以被多次检索。

test_overwrite_values_by_key ¶

test_overwrite_values_by_key(
    kv_store: BaseStore[str, V], three_values: tuple[V, V, V]
) -> None

测试我们可以使用 mset 按键覆盖值。

test_yield_keys ¶

test_yield_keys(kv_store: BaseStore[str, V], three_values: tuple[V, V, V]) -> None

测试我们可以从存储中生成键。

AsyncCacheTestSuite ¶

基类：BaseStandardTests

用于检查 LLM 缓存层的 BaseCache API 的测试套件。

此测试套件验证 LLM 缓存层的基本缓存 API。

该测试套件专为同步缓存层设计。

实现者应继承此类测试套件，并提供一个为每个测试返回空缓存的 fixture。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`cache`	获取要测试的缓存类。
`get_sample_prompt`	返回用于测试的示例文本提示。
`get_sample_llm_string`	返回用于测试的 LLM 示例字符串。
`get_sample_generation`	返回用于测试的 Generation 示例对象。
`test_cache_is_empty`	测试缓存是否为空。
`test_update_cache`	测试更新缓存。
`test_cache_still_empty`	测试缓存是否仍然为空。
`test_clear_cache`	测试清除缓存。
`test_cache_miss`	测试缓存未命中。
`test_cache_hit`	测试缓存命中。
`test_update_cache_with_multiple_generations`	测试使用多个 Generation 对象更新缓存。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

cache `abstractmethod` `async` ¶

cache() -> BaseCache

获取要测试的缓存类。

返回的缓存应为空。

get_sample_prompt ¶

get_sample_prompt() -> str

返回用于测试的示例文本提示。

get_sample_llm_string ¶

get_sample_llm_string() -> str

返回用于测试的 LLM 示例字符串。

get_sample_generation ¶

get_sample_generation() -> Generation

返回用于测试的 Generation 示例对象。

test_cache_is_empty `async` ¶

test_cache_is_empty(cache: BaseCache) -> None

测试缓存是否为空。

test_update_cache `async` ¶

test_update_cache(cache: BaseCache) -> None

测试更新缓存。

test_cache_still_empty `async` ¶

test_cache_still_empty(cache: BaseCache) -> None

测试缓存是否仍然为空。

此测试应在更新缓存的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

test_clear_cache `async` ¶

test_clear_cache(cache: BaseCache) -> None

测试清除缓存。

test_cache_miss `async` ¶

test_cache_miss(cache: BaseCache) -> None

测试缓存未命中。

test_cache_hit `async` ¶

test_cache_hit(cache: BaseCache) -> None

测试缓存命中。

test_update_cache_with_multiple_generations `async` ¶

test_update_cache_with_multiple_generations(cache: BaseCache) -> None

测试使用多个 Generation 对象更新缓存。

SyncCacheTestSuite ¶

基类：BaseStandardTests

用于检查 LLM 缓存层的 BaseCache API 的测试套件。

此测试套件验证 LLM 缓存层的基本缓存 API。

该测试套件专为同步缓存层设计。

实现者应继承此类测试套件，并提供一个为每个测试返回空缓存的 fixture。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`cache`	获取要测试的缓存类。
`get_sample_prompt`	返回用于测试的示例文本提示。
`get_sample_llm_string`	返回用于测试的 LLM 示例字符串。
`get_sample_generation`	返回用于测试的 Generation 示例对象。
`test_cache_is_empty`	测试缓存是否为空。
`test_update_cache`	测试更新缓存。
`test_cache_still_empty`	测试缓存是否仍然为空。
`test_clear_cache`	测试清除缓存。
`test_cache_miss`	测试缓存未命中。
`test_cache_hit`	测试缓存命中。
`test_update_cache_with_multiple_generations`	测试使用多个 Generation 对象更新缓存。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

cache `abstractmethod` ¶

cache() -> BaseCache

获取要测试的缓存类。

返回的缓存应为空。

get_sample_prompt ¶

get_sample_prompt() -> str

返回用于测试的示例文本提示。

get_sample_llm_string ¶

get_sample_llm_string() -> str

返回用于测试的 LLM 示例字符串。

get_sample_generation ¶

get_sample_generation() -> Generation

返回用于测试的 Generation 示例对象。

test_cache_is_empty ¶

test_cache_is_empty(cache: BaseCache) -> None

测试缓存是否为空。

test_update_cache ¶

test_update_cache(cache: BaseCache) -> None

测试更新缓存。

test_cache_still_empty ¶

test_cache_still_empty(cache: BaseCache) -> None

测试缓存是否仍然为空。

此测试应在更新缓存的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

test_clear_cache ¶

test_clear_cache(cache: BaseCache) -> None

测试清除缓存。

test_cache_miss ¶

test_cache_miss(cache: BaseCache) -> None

测试缓存未命中。

test_cache_hit ¶

test_cache_hit(cache: BaseCache) -> None

测试缓存命中。

test_update_cache_with_multiple_generations ¶

test_update_cache_with_multiple_generations(cache: BaseCache) -> None

测试使用多个 Generation 对象更新缓存。

ChatModelIntegrationTests ¶

基类：ChatModelTests

聊天模型集成测试的基类。

测试子类必须实现 chat_model_class 和 chat_model_params 属性，以指定要测试的模型及其初始化参数。

from typing import Type

from langchain_tests.integration_tests import ChatModelIntegrationTests
from my_package.chat_models import MyChatModel


class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def chat_model_class(self) -> Type[MyChatModel]:
        # Return the chat model class to test here
        return MyChatModel

    @property
    def chat_model_params(self) -> dict:
        # Return initialization parameters for the model.
        return {"model": "model-001", "temperature": 0}

注意

单个测试方法的 API 参考包括故障排除提示。

测试子类必须实现以下两个属性

chat_model_class：要测试的聊天模型类，例如 ChatParrotLink。

@property
def chat_model_class(self) -> Type[ChatParrotLink]:
    return ChatParrotLink

chat_model_params：聊天模型的初始化参数。

@property
def chat_model_params(self) -> dict:
    return {"model": "bird-brain-001", "temperature": 0}

此外，测试子类可以通过选择性地覆盖以下属性来控制要测试的功能（例如工具调用或多模态）。展开以查看详细信息

has_tool_calling

布尔属性，指示聊天模型是否支持工具调用。

默认情况下，这是由聊天模型的 bind_tools 方法是否被重写来确定的。通常不需要在测试类上重写它。

覆盖示例

@property
def has_tool_calling(self) -> bool:
    return True

tool_choice_value

在测试中使用时用于工具选择的值。

警告

自 0.3.15 版起已弃用。此属性将在 0.3.20 版中移除。如果模型支持 `tool_choice`，它应该接受 `tool_choice="any"` 和 `tool_choice=<工具的字符串名称>`。如果模型不支持强制工具调用，请将 `has_tool_choice` 属性重写为返回 `False`。

@property
def tool_choice_value(self) -> str | None:
    return "any"

has_tool_choice

布尔属性，指示聊天模型是否支持通过 `tool_choice` 参数强制进行工具调用。

默认情况下，这是由该参数是否包含在相应 `bind_tools` 方法的签名中来确定的。

如果为 `True`，此功能的最低要求是 `tool_choice="any"` 将强制进行工具调用，而 `tool_choice=<工具名称>` 将强制调用特定工具。

覆盖示例

@property
def has_tool_choice(self) -> bool:
    return False

has_structured_output

布尔属性，指示聊天模型是否支持结构化输出。

默认情况下，这是由聊天模型的 with_structured_output 方法是否被重写来确定的。如果打算使用基础实现，则应重写此方法。

请参阅：https://docs.langchain.org.cn/oss/python/langchain/structured-output

@property
def has_structured_output(self) -> bool:
    return True

structured_output_kwargs

字典属性，可用于为 with_structured_output 指定额外的关键字参数。对于测试不同的模型很有用。

@property
def structured_output_kwargs(self) -> dict:
    return {"method": "function_calling"}

supports_json_mode

布尔属性，指示聊天模型是否在 with_structured_output 中支持 JSON 模式。

请参阅：https://docs.langchain.org.cn/oss/python/langchain/structured-output

@property
def supports_json_mode(self) -> bool:
    return True

supports_image_inputs

布尔属性，指示聊天模型是否支持图像输入。

默认为 `False`。

如果设置为 `True`，将通过输入形状为 `ImageContentBlock` 的内容来测试聊天模型

{
    "type": "image",
    "base64": "<base64 image data>",
    "mime_type": "image/jpeg",  # or appropriate MIME type
}

除了 OpenAI 风格的内容块之外

{
    "type": "image_url",
    "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
}

请参阅 https://docs.langchain.org.cn/oss/python/langchain/models#multimodal

@property
def supports_image_inputs(self) -> bool:
    return True

supports_image_urls

布尔属性，指示聊天模型是否支持来自 URL 的图像输入。

默认为 `False`。

如果设置为 `True`，将使用以下形式的内容块来测试聊天模型

{
    "type": "image",
    "url": "https://...",
}

请参阅 https://docs.langchain.org.cn/oss/python/langchain/models#multimodal

@property
def supports_image_urls(self) -> bool:
    return True

supports_pdf_inputs

布尔属性，指示聊天模型是否支持 PDF 输入。

默认为 `False`。

如果设置为 `True`，将通过输入形状为 `FileContentBlock` 的内容来测试聊天模型

{
    "type": "file",
    "base64": "<base64 file data>",
    "mime_type": "application/pdf",
}

请参阅 https://docs.langchain.org.cn/oss/python/langchain/models#multimodal

@property
def supports_pdf_inputs(self) -> bool:
    return True

supports_audio_inputs

布尔属性，指示聊天模型是否支持音频输入。

默认为 `False`。

如果设置为 `True`，将通过输入形状为 `AudioContentBlock` 的内容来测试聊天模型

{
    "type": "audio",
    "base64": "<base64 audio data>",
    "mime_type": "audio/wav",  # or appropriate MIME type
}

请参阅 https://docs.langchain.org.cn/oss/python/langchain/models#multimodal

@property
def supports_audio_inputs(self) -> bool:
    return True

supports_video_inputs

布尔属性，指示聊天模型是否支持图像输入。

默认为 `False`。目前没有为此功能编写测试。

returns_usage_metadata

布尔属性，指示聊天模型是否在调用和流式响应中返回使用情况元数据。

默认为 `True`。

`usage_metadata` 是 `AIMessage` 对象上的一个可选字典属性，用于跟踪输入和输出令牌。查看更多。

@property
def returns_usage_metadata(self) -> bool:
    return False

支持 `usage_metadata` 的模型还应在 `AIMessage` 的 `response_metadata` 中返回底层模型的名称。

supports_anthropic_inputs

布尔属性，指示聊天模型是否支持 Anthropic 风格的输入。

这些输入可能包含“工具使用”和“工具结果”内容块，例如：

[
    {"type": "text", "text": "Hmm let me think about that"},
    {
        "type": "tool_use",
        "input": {"fav_color": "green"},
        "id": "foo",
        "name": "color_picker",
    },
]

如果设置为 `True`，将使用此形式的内容块测试聊天模型。

@property
def supports_anthropic_inputs(self) -> bool:
    return False

supports_image_tool_message

布尔属性，指示聊天模型是否支持包含图像内容的 `ToolMessage`，例如在 OpenAI 聊天完成格式中

ToolMessage(
    content=[
        {
            "type": "image_url",
            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
        },
    ],
    tool_call_id="1",
    name="random_image",
)

以及 LangChain `ImageContentBlock` 格式

ToolMessage(
    content=[
        {
            "type": "image",
            "base64": image_data,
            "mime_type": "image/jpeg",
        },
    ],
    tool_call_id="1",
    name="random_image",
)

如果设置为 `True`，将使用包含此形式的 `ToolMessage` 对象的消息序列来测试聊天模型。

@property
def supports_image_tool_message(self) -> bool:
    return False

supports_pdf_tool_message

布尔属性，指示聊天模型是否支持使用 LangChain `FileContentBlock` 格式包含 PDF 内容的 `ToolMessage`

ToolMessage(
    content=[
        {
            "type": "file",
            "base64": pdf_data,
            "mime_type": "application/pdf",
        },
    ],
    tool_call_id="1",
    name="random_pdf",
)

如果设置为 `True`，将使用包含此形式的 `ToolMessage` 对象的消息序列来测试聊天模型。

@property
def supports_pdf_tool_message(self) -> bool:
    return False

supported_usage_metadata_details

控制在调用和流中发出的使用情况元数据详细信息的属性。

`usage_metadata` 是 `AIMessage` 对象上的一个可选字典属性，用于跟踪输入和输出令牌。查看更多。

它包括可选的键 `input_token_details` 和 `output_token_details`，可以跟踪与特殊类型令牌（如缓存、音频或推理）相关的使用情况详细信息。

仅当提供了这些详细信息时才需要重写。

enable_vcr_tests

控制是否启用依赖于 VCR 缓存 HTTP 调用的特定测试（如基准测试）的属性。

要启用这些测试，请按照以下步骤操作

将 `enable_vcr_tests` 属性重写为返回 `True`

@property
def enable_vcr_tests(self) -> bool:
    return True

配置 VCR 以从录制文件中排除敏感的标头和其他信息。

警告

VCR 默认会在录制文件中记录身份验证标头和其他敏感信息。请阅读下文，了解如何配置在录制文件中记录哪些信息。

要向 VCR 添加配置，请在 `tests/` 目录中添加一个 `conftest.py` 文件，并在那里实现 `vcr_config` fixture。

`langchain-tests` 从 VCR 录制文件中排除了 `'authorization'`、`'x-api-key'` 和 `'api-key'` 标头。要采用此配置，您需要如下所示添加 `conftest.py`。您还可以排除其他标头、覆盖默认排除项或对 VCR 配置应用其他自定义。请参见下面的示例

tests/conftest.py

import pytest
from langchain_tests.conftest import (
    _base_vcr_config as _base_vcr_config,
)

_EXTRA_HEADERS = [
    # Specify additional headers to redact
    ("user-agent", "PLACEHOLDER"),
]


def remove_response_headers(response: dict) -> dict:
    # If desired, remove or modify headers in the response.
    response["headers"] = {}
    return response


@pytest.fixture(scope="session")
def vcr_config(_base_vcr_config: dict) -> dict:  # noqa: F811
    """Extend the default configuration from langchain_tests."""
    config = _base_vcr_config.copy()
    config.setdefault("filter_headers", []).extend(_EXTRA_HEADERS)
    config["before_record_response"] = remove_response_headers

    return config

压缩录制文件

`langchain-tests` 包含一个自定义的 VCR 序列化器，它使用 gzip 压缩录制文件。要使用它，请将 `yaml.gz` 序列化器注册到您的 VCR fixture 中，并在配置中启用此序列化器。请参见下面的示例

tests/conftest.py

import pytest
from langchain_tests.conftest import (
    CustomPersister,
    CustomSerializer,
)
from langchain_tests.conftest import (
    _base_vcr_config as _base_vcr_config,
)
from vcr import VCR

_EXTRA_HEADERS = [
    # Specify additional headers to redact
    ("user-agent", "PLACEHOLDER"),
]


def remove_response_headers(response: dict) -> dict:
    # If desired, remove or modify headers in the response.
    response["headers"] = {}
    return response


@pytest.fixture(scope="session")
def vcr_config(_base_vcr_config: dict) -> dict:  # noqa: F811
    """Extend the default configuration from langchain_tests."""
    config = _base_vcr_config.copy()
    config.setdefault("filter_headers", []).extend(_EXTRA_HEADERS)
    config["before_record_response"] = remove_response_headers
    # New: enable serializer and set file extension
    config["serializer"] = "yaml.gz"
    config["path_transformer"] = VCR.ensure_suffix(".yaml.gz")

    return config


def pytest_recording_configure(config: dict, vcr: VCR) -> None:
    vcr.register_persister(CustomPersister())
    vcr.register_serializer("yaml.gz", CustomSerializer())

您可以使用以下命令检查压缩录制文件的内容（例如，以确保没有记录敏感信息）

gunzip -k /path/to/tests/cassettes/TestClass_test.yaml.gz

或通过使用序列化器

from langchain_tests.conftest import (
    CustomPersister,
    CustomSerializer,
)

cassette_path = "/path/to/tests/cassettes/TestClass_test.yaml.gz"
requests, responses = CustomPersister().load_cassette(
    path, CustomSerializer()
)

运行测试以生成 VCR 录制文件。

示例
```
uv run python -m pytest tests/integration_tests/test_chat_models.py::TestMyModel::test_stream_time
```
这将在 `tests/integration_tests/cassettes/` 中为测试生成一个 VCR 录制文件。

警告

您应该检查生成的录制文件，以确保它不包含敏感信息。如果包含，您可以修改 `vcr_config` fixture 以排除标头或在记录响应之前对其进行修改。

然后，您可以将录制文件提交到您的存储库中。后续的测试运行将使用录制文件而不是进行 HTTP 调用。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`model`	模型 fixture。
`my_adder_tool`	加法器工具 fixture。
`test_invoke`	测试以验证 `model.invoke(simple_message)` 是否有效。
`test_ainvoke`	测试以验证 `await model.ainvoke(simple_message)` 是否有效。
`test_stream`	测试以验证 `model.stream(simple_message)` 是否有效。
`test_astream`	测试以验证 `await model.astream(simple_message)` 是否有效。
`test_batch`	测试以验证 `model.batch([messages])` 是否有效。
`test_abatch`	测试以验证 `await model.abatch([messages])` 是否有效。
`test_conversation`	测试以验证模型是否可以处理多轮对话。
`test_double_messages_conversation`	测试以验证模型是否可以处理双消息对话。
`test_usage_metadata`	测试以验证模型是否返回正确的使用情况元数据。
`test_usage_metadata_streaming`	在流式模式下测试使用情况元数据。
`test_stop_sequence`	测试模型在使用 `stop` 参数调用时不会失败。
`test_tool_calling`	测试模型是否生成工具调用。
`test_tool_calling_async`	测试模型是否生成工具调用。
`test_bind_runnables_as_tools`	测试将可运行对象绑定为工具。
`test_tool_message_histories_string_content`	测试消息历史记录是否与字符串工具内容兼容。
`test_tool_message_histories_list_content`	测试消息历史记录是否与列表工具内容兼容。
`test_tool_choice`	测试 `tool_choice` 参数。
`test_tool_calling_with_no_arguments`	测试模型是否为无参数的工具生成工具调用。
`test_tool_message_error_status`	测试 `ToolMessage` 的 `status="error"` 是否可以被处理。
`test_structured_few_shot_examples`	测试模型是否可以处理带工具调用的少样本示例。
`test_structured_output`	测试以验证在调用和流上都生成了结构化输出。
`test_structured_output_async`	测试以验证在调用和流上都生成了结构化输出。
`test_structured_output_pydantic_2_v1`	使用 pydantic.v1.BaseModel 测试结构化输出。
`test_structured_output_optional_param`	测试带可选参数的结构化输出。
`test_json_mode`	通过 JSON 模式测试结构化输出。
`test_pdf_inputs`	测试模型是否可以处理 PDF 输入。
`test_audio_inputs`	测试模型是否可以处理音频输入。
`test_image_inputs`	测试模型是否可以处理图像输入。
`test_image_tool_message`	测试模型是否可以处理带图像输入的 `ToolMessage` 对象。
`test_pdf_tool_message`	测试模型是否可以处理带 PDF 输入的 `ToolMessage` 对象。
`test_anthropic_inputs`	测试模型是否可以处理 Anthropic 风格的消息历史记录。
`test_message_with_name`	测试 `name` 字段有值的 `HumanMessage` 是否可以被处理。
`test_agent_loop`	测试模型是否支持简单的 ReAct 代理循环。
`test_stream_time`	测试流式传输不会引入不必要的开销。
`invoke_with_audio_input`	使用音频输入调用。
`invoke_with_audio_output`	使用音频输出调用。
`invoke_with_reasoning_output`	使用推理输出调用。
`invoke_with_cache_read_input`	使用缓存读取输入调用。
`invoke_with_cache_creation_input`	使用缓存创建输入调用。
`test_unicode_tool_call_integration`	工具调用中 Unicode 字符的通用集成测试。

chat_model_class `abstractmethod` `property` ¶

chat_model_class: type[BaseChatModel]

要测试的聊天模型类，例如 `ChatParrotLink`。

chat_model_params `property` ¶

chat_model_params: dict

聊天模型的初始化参数。

has_tool_calling `property` ¶

has_tool_calling: bool

模型是否支持工具调用。

tool_choice_value `property` ¶

tool_choice_value: str | None

在测试中使用时用于工具选择的（None 或 str）值。

has_tool_choice `property` ¶

has_tool_choice: bool

模型是否支持工具调用。

has_structured_output `property` ¶

has_structured_output: bool

聊天模型是否支持结构化输出。

structured_output_kwargs `property` ¶

structured_output_kwargs: dict

如果指定，则为 `with_structured_output` 的额外关键字参数。

supports_json_mode `property` ¶

supports_json_mode: bool

聊天模型是否支持 JSON 模式。

supports_image_inputs `property` ¶

supports_image_inputs: bool

支持图像输入。

聊天模型是否支持图像输入，默认为 `False`。

supports_image_urls `property` ¶

supports_image_urls: bool

支持来自 URL 的图像输入。

聊天模型是否支持来自 URL 的图像输入，默认为 `False`。

supports_pdf_inputs `property` ¶

supports_pdf_inputs: bool

聊天模型是否支持 PDF 输入，默认为 `False`。

supports_audio_inputs `property` ¶

supports_audio_inputs: bool

支持音频输入。

聊天模型是否支持音频输入，默认为 `False`。

supports_video_inputs `property` ¶

supports_video_inputs: bool

支持视频输入。

聊天模型是否支持视频输入，默认为 `False`。

目前没有为此功能编写测试。

returns_usage_metadata `property` ¶

returns_usage_metadata: bool

返回使用情况元数据。

聊天模型是否在调用和流式响应中返回使用情况元数据。

supports_anthropic_inputs `property` ¶

supports_anthropic_inputs: bool

聊天模型是否支持 Anthropic 风格的输入。

supports_image_tool_message `property` ¶

supports_image_tool_message: bool

支持图像 `ToolMessage` 对象。

聊天模型是否支持包含图像内容的 `ToolMessage` 对象。

supports_pdf_tool_message `property` ¶

supports_pdf_tool_message: bool

支持 PDF `ToolMessage` 对象。

聊天模型是否支持包含 PDF 内容的 `ToolMessage` 对象。

enable_vcr_tests `property` ¶

enable_vcr_tests: bool

是否为聊天模型启用 VCR 测试。

警告

有关更多信息，请参阅`上面 `的 `enable_vcr_tests` 下拉菜单。

supported_usage_metadata_details `property` ¶

supported_usage_metadata_details: dict[
    Literal["invoke", "stream"],
    list[
        Literal[
            "audio_input",
            "audio_output",
            "reasoning_output",
            "cache_read_input",
            "cache_creation_input",
        ]
    ],
]

支持的使用情况元数据详细信息。

在调用和流中发出的使用情况元数据详细信息。只有当模型返回这些详细信息时才需要重写。

standard_chat_model_params `property` ¶

standard_chat_model_params: dict

聊天模型的标准参数。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

model ¶

model(request: Any) -> BaseChatModel

模型 fixture。

my_adder_tool ¶

my_adder_tool() -> BaseTool

加法器工具 fixture。

test_invoke ¶

test_invoke(model: BaseChatModel) -> None

测试以验证 `model.invoke(simple_message)` 是否有效。

所有集成都应通过此测试。

故障排除

如果此测试失败，您应确保您的 `_generate` 方法不会引发任何异常，并且返回一个有效的 `langchain_core.outputs.chat_result.ChatResult`，如下所示：

return ChatResult(
    generations=[ChatGeneration(message=AIMessage(content="Output text"))]
)

test_ainvoke `async` ¶

test_ainvoke(model: BaseChatModel) -> None

测试以验证 `await model.ainvoke(simple_message)` 是否有效。

所有集成都应通过此测试。通过此测试并不表示实现了“原生异步”，而是表示该模型可以在异步上下文中使用。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_invoke`，因为 `ainvoke` 有一个默认实现，它在异步上下文中调用 `invoke`。

如果该测试通过但此测试不通过，您应确保您的 _agenerate 方法不会引发任何异常，并且返回一个有效的 `langchain_core.outputs.chat_result.ChatResult`，如下所示：

return ChatResult(
    generations=[ChatGeneration(message=AIMessage(content="Output text"))]
)

test_stream ¶

test_stream(model: BaseChatModel) -> None

测试以验证 `model.stream(simple_message)` 是否有效。

所有集成都应通过此测试。通过此测试并不表示实现了“流式”处理，而是表示该模型可以在流式上下文中使用。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_invoke`，因为 `stream` 有一个默认实现，它调用 `invoke` 并将结果作为单个块返回。

如果该测试通过但此测试不通过，您应确保您的 `_stream` 方法不会引发任何异常，并且它会生成有效的 `langchain_core.outputs.chat_generation.ChatGenerationChunk` 对象，如下所示：

yield ChatGenerationChunk(message=AIMessageChunk(content="chunk text"))

test_astream `async` ¶

test_astream(model: BaseChatModel) -> None

测试以验证 `await model.astream(simple_message)` 是否有效。

所有集成都应通过此测试。通过此测试并不表示实现了“原生异步”或“流式”处理，而是表示该模型可以在异步流式上下文中使用。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_stream` 和 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_ainvoke`，因为 `astream` 有一个默认实现，如果实现了 `_stream`，它会在异步上下文中调用 `_stream`；如果未实现，则调用 `ainvoke` 并将结果作为单个块返回。

如果这些测试通过但此测试不通过，您应确保您的 `_astream` 方法不会引发任何异常，并且它会生成有效的 `langchain_core.outputs.chat_generation.ChatGenerationChunk` 对象，如下所示：

yield ChatGenerationChunk(message=AIMessageChunk(content="chunk text"))

test_batch ¶

test_batch(model: BaseChatModel) -> None

测试以验证 `model.batch([messages])` 是否有效。

所有集成都应通过此测试。测试模型在单个批次中处理多个提示的能力。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_invoke`，因为 `batch` 有一个默认实现，它会为批次中的每条消息调用 `invoke`。

如果该测试通过但此测试不通过，您应确保您的 `batch` 方法不会引发任何异常，并且它返回一个有效的 `langchain_core.messages.AIMessage` 对象列表。

test_abatch `async` ¶

test_abatch(model: BaseChatModel) -> None

测试以验证 `await model.abatch([messages])` 是否有效。

所有集成都应通过此测试。测试模型异步处理单个批次中多个提示的能力。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_batch` 和 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_ainvoke`，因为 `abatch` 有一个默认实现，它会为批次中的每条消息调用 `ainvoke`。

如果这些测试通过但此测试不通过，您应确保您的 `abatch` 方法不会引发任何异常，并且它返回一个有效的 `langchain_core.messages.AIMessage` 对象列表。

test_conversation ¶

test_conversation(model: BaseChatModel) -> None

测试以验证模型是否可以处理多轮对话。

所有集成都应通过此测试。测试模型处理交替的人类和 AI 消息序列作为生成下一响应的上下文的能力。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_invoke`，因为此测试也使用 `model.invoke`。

如果该测试通过但此测试不通过，您应验证：1. 您的模型正确处理消息历史记录 2. 模型保持了来自先前消息的适当上下文 3. 响应是有效的 `langchain_core.messages.AIMessage`

test_double_messages_conversation ¶

test_double_messages_conversation(model: BaseChatModel) -> None

测试以验证模型是否可以处理双消息对话。

所有集成都应通过此测试。测试模型处理双系统、双人类和双 AI 消息序列作为生成下一响应的上下文的能力。

故障排除

首先，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_invoke`，因为此测试也使用 `model.invoke`。

其次，调试 `langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_conversation`，因为该测试是没有双消息的“基本情况”。

如果该测试通过但此测试不通过，您应验证：1. 您的模型 API 可以处理双消息，或者集成应在将消息发送到 API 之前合并消息。2. 响应是有效的 `langchain_core.messages.AIMessage`

test_usage_metadata ¶

test_usage_metadata(model: BaseChatModel) -> None

测试以验证模型是否返回正确的使用情况元数据。

此测试是可选的，如果模型不返回使用情况元数据，则应跳过（请参阅下面的配置）。

行为在 0.3.17 中已更改

另外检查响应元数据中是否存在 `model_name`，这对于回调处理程序中的使用情况跟踪是必需的。

配置

默认情况下，运行此测试。

要禁用此功能，请在您的测试类中将 `returns_usage_metadata` 设置为 `False`

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def returns_usage_metadata(self) -> bool:
        return False

此测试还可以根据 `supported_usage_metadata_details` 属性检查特定类型使用情况元数据的格式。应根据模型支持跟踪的令牌类型配置此属性，如下所示：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supported_usage_metadata_details(self) -> dict:
        return {
            "invoke": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
            "stream": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
        }

故障排除

如果此测试失败，请首先验证您的模型是否在 `_generate` 中返回附加到返回的 `AIMessage` 对象的 `langchain_core.messages.ai.UsageMetadata` 字典

return ChatResult(
    generations=[
        ChatGeneration(
            message=AIMessage(
                content="Output text",
                usage_metadata={
                    "input_tokens": 350,
                    "output_tokens": 240,
                    "total_tokens": 590,
                    "input_token_details": {
                        "audio": 10,
                        "cache_creation": 200,
                        "cache_read": 100,
                    },
                    "output_token_details": {
                        "audio": 10,
                        "reasoning": 200,
                    },
                },
            )
        )
    ]
)

同时检查响应的 `usage_metadata` 中是否包含 `model_name` 键。

test_usage_metadata_streaming ¶

test_usage_metadata_streaming(model: BaseChatModel) -> None

在流式模式下测试使用情况元数据。

测试以验证模型在流式模式下是否返回正确的使用情况元数据。

行为在 0.3.17 中已更改

另外检查响应元数据中是否存在 `model_name`，这对于回调处理程序中的使用情况跟踪是必需的。

配置

默认情况下，运行此测试。要禁用此功能，请在您的测试类中将 `returns_usage_metadata` 设置为 `False`

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def returns_usage_metadata(self) -> bool:
        return False

此测试还可以根据 `supported_usage_metadata_details` 属性检查特定类型使用情况元数据的格式。应根据模型支持跟踪的令牌类型配置此属性，如下所示：

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supported_usage_metadata_details(self) -> dict:
        return {
            "invoke": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
            "stream": [
                "audio_input",
                "audio_output",
                "reasoning_output",
                "cache_read_input",
                "cache_creation_input",
            ],
        }

故障排除

如果此测试失败，请首先验证您的模型在 `_stream` 中是否生成附加到返回的 `AIMessage` 对象的 `langchain_core.messages.ai.UsageMetadata` 字典，并且这些字典的总和等于总使用情况元数据。

请注意，`input_tokens` 应仅包含在其中一个块中（通常是第一个或最后一个块），其余块应为 `0` 或 `None`，以避免多次计算输入令牌。

`output_tokens` 通常计算每个块中的令牌数，而不是总和。只要所有块的 `output_tokens` 之和不为 `0`，此测试就会通过。

yield ChatResult(
    generations=[
        ChatGeneration(
            message=AIMessage(
                content="Output text",
                usage_metadata={
                    "input_tokens": (
                        num_input_tokens if is_first_chunk else 0
                    ),
                    "output_tokens": 11,
                    "total_tokens": (
                        11 + num_input_tokens if is_first_chunk else 11
                    ),
                    "input_token_details": {
                        "audio": 10,
                        "cache_creation": 200,
                        "cache_read": 100,
                    },
                    "output_token_details": {
                        "audio": 10,
                        "reasoning": 200,
                    },
                },
            )
        )
    ]
)

同时检查聚合响应的 `usage_metadata` 中是否包含 `model_name` 键。

test_stop_sequence ¶

test_stop_sequence(model: BaseChatModel) -> None

测试模型在使用 `stop` 参数调用时不会失败。

`stop` 参数是用于在特定令牌处停止生成的标准参数。

关于标准参数的更多信息.

所有集成都应通过此测试。

故障排除

如果此测试失败，请检查 `_generate`（以及 `_stream` 和异步变体）的函数签名是否接受 `stop` 参数

def _generate(
    self,
    messages: List[BaseMessage],
    stop: list[str] | None = None,
    run_manager: CallbackManagerForLLMRun | None = None,
    **kwargs: Any,
) -> ChatResult:

test_tool_calling ¶

test_tool_calling(model: BaseChatModel) -> None

测试模型是否生成工具调用。

如果测试类上的 `has_tool_calling` 属性设置为 `False`，则跳过此测试。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 `bind_tools` 是否已实现，以将 LangChain 工具对象正确转换为您的聊天模型的适当模式。

如果聊天模型不支持 tool_choice 参数，此测试可能会失败。该参数可用于强制进行工具调用。如果不支持 tool_choice 并且模型持续无法通过此测试，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_tool_calling(self, model: BaseChatModel) -> None:
    super().test_tool_calling(model)

另外，在只绑定一个工具的情况下，请确保 tool_choice 支持字符串 'any' 以强制调用该工具。

test_tool_calling_async `async` ¶

test_tool_calling_async(model: BaseChatModel) -> None

测试模型是否生成工具调用。

如果测试类上的 `has_tool_calling` 属性设置为 `False`，则跳过此测试。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 `bind_tools` 是否已实现，以将 LangChain 工具对象正确转换为您的聊天模型的适当模式。

如果聊天模型不支持 tool_choice 参数，此测试可能会失败。该参数可用于强制进行工具调用。如果不支持 tool_choice 并且模型持续无法通过此测试，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Does not support tool_choice."))
async def test_tool_calling_async(self, model: BaseChatModel) -> None:
    await super().test_tool_calling_async(model)

另外，在只绑定一个工具的情况下，请确保 tool_choice 支持字符串 'any' 以强制调用该工具。

test_bind_runnables_as_tools ¶

test_bind_runnables_as_tools(model: BaseChatModel) -> None

测试将可运行对象绑定为工具。

测试模型是否能为派生自 LangChain runnable 的工具生成工具调用。如果测试类上的 has_tool_calling 属性设置为 False，则此测试将被跳过。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 `bind_tools` 是否已实现，以将 LangChain 工具对象正确转换为您的聊天模型的适当模式。

如果聊天模型不支持 tool_choice 参数，此测试可能会失败。该参数可用于强制进行工具调用。如果不支持 tool_choice 并且模型持续无法通过此测试，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_bind_runnables_as_tools(self, model: BaseChatModel) -> None:
    super().test_bind_runnables_as_tools(model)

否则，请确保在测试类上正确指定了 tool_choice_value 属性。

test_tool_message_histories_string_content ¶

test_tool_message_histories_string_content(
    model: BaseChatModel, my_adder_tool: BaseTool
) -> None

测试消息历史记录是否与字符串工具内容兼容。

例如，对于 OpenAI 格式的内容。如果模型通过此测试，它应与遵循 OpenAI 格式的提供商生成的消息兼容。

如果模型不支持工具调用，应跳过此测试（参见下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查

模型是否能正确处理包含内容为 "" 的 AIMessage 对象的消息历史记录。
AIMessage 对象上的 tool_calls 属性是否被正确处理并以适当的格式传递给模型。
模型是否能正确处理具有字符串内容和任意字符串值 tool_call_id 的 ToolMessage 对象。

如果工具调用已实现但不支持此格式，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_tool_message_histories_string_content(self, *args: Any) -> None:
    super().test_tool_message_histories_string_content(*args)

test_tool_message_histories_list_content ¶

test_tool_message_histories_list_content(
    model: BaseChatModel, my_adder_tool: BaseTool
) -> None

测试消息历史记录是否与列表工具内容兼容。

例如，对于 Anthropic 格式的内容。

这些消息历史将包括带有“工具使用”和内容块的 AIMessage 对象，例如：

[
    {"type": "text", "text": "Hmm let me think about that"},
    {
        "type": "tool_use",
        "input": {"fav_color": "green"},
        "id": "foo",
        "name": "color_picker",
    },
]

如果模型不支持工具调用，应跳过此测试（参见下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查

模型是否能正确处理包含列表内容的 AIMessage 对象的消息历史记录。
AIMessage 对象上的 tool_calls 属性是否被正确处理并以适当的格式传递给模型。
模型是否能正确处理具有字符串内容和任意字符串值 tool_call_id 的 ToolMessage 对象。

如果工具调用已实现但不支持此格式，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_tool_message_histories_list_content(self, *args: Any) -> None:
    super().test_tool_message_histories_list_content(*args)

test_tool_choice ¶

test_tool_choice(model: BaseChatModel) -> None

测试 `tool_choice` 参数。

测试模型是否能通过 tool_choice 参数强制进行工具调用。如果测试类上的 has_tool_choice 属性设置为 False，则此测试将被跳过。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 has_tool_choice 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_choice(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 test_tool_calling 测试是否通过。如果没有通过，请首先参考该测试中的故障排除步骤。

如果 test_tool_calling 通过，请检查底层模型是否支持强制工具调用。如果支持，bind_tools 应接受一个 tool_choice 参数，该参数可用于强制进行工具调用。

它应接受 (1) 字符串 'any' 以强制调用绑定的工具，以及 (2) 工具的字符串名称以强制调用该工具。

test_tool_calling_with_no_arguments ¶

test_tool_calling_with_no_arguments(model: BaseChatModel) -> None

测试模型是否为无参数的工具生成工具调用。

如果测试类上的 `has_tool_calling` 属性设置为 `False`，则跳过此测试。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 bind_tools 是否已实现，以正确地将 LangChain 工具对象转换为适用于您的聊天模型的模式。它应正确处理工具没有参数的情况。

如果聊天模型不支持 tool_choice 参数，此测试可能会失败。该参数可用于强制进行工具调用。如果提供商不支持这种形式的工具，此测试也可能失败。在这些情况下，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_tool_calling_with_no_arguments(self, model: BaseChatModel) -> None:
    super().test_tool_calling_with_no_arguments(model)

另外，在只绑定一个工具的情况下，请确保 tool_choice 支持字符串 'any' 以强制调用该工具。

test_tool_message_error_status ¶

test_tool_message_error_status(model: BaseChatModel, my_adder_tool: BaseTool) -> None

测试 `ToolMessage` 的 `status="error"` 是否可以被处理。

这些消息可能采用以下形式：

ToolMessage(
    "Error: Missing required argument 'b'.",
    name="my_adder_tool",
    tool_call_id="abc123",
    status="error",
)

如果可能，应解析 status 字段并适当地传递给模型。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 ToolMessage 对象上的 status 字段是被忽略还是被适当地传递给模型。

test_structured_few_shot_examples ¶

test_structured_few_shot_examples(
    model: BaseChatModel, my_adder_tool: BaseTool
) -> None

测试模型是否可以处理带工具调用的少样本示例。

这些表示为一系列具有以下形式的消息：

带有字符串内容的 HumanMessage；
AIMessage，其 tool_calls 属性已填充；
带有字符串内容的 ToolMessage；
带有字符串内容的 AIMessage（一个答案）；
带有字符串内容的 HumanMessage（一个后续问题）。

如果模型不支持工具调用，应跳过此测试（参见下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

此测试使用 langchain_core 中的一个工具函数来生成一系列代表“少样本”示例的消息。

如果此测试失败，请检查模型是否能正确处理此消息序列。

如果工具调用已实现但不支持此格式，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Not implemented."))
def test_structured_few_shot_examples(self, *args: Any) -> None:
    super().test_structured_few_shot_examples(*args)

test_structured_output ¶

test_structured_output(
    model: BaseChatModel, schema_type: Literal["pydantic", "typeddict", "json_schema"]
) -> None

测试以验证在调用和流上都生成了结构化输出。

此测试是可选的，如果模型不支持结构化输出，则应跳过（参见下面的配置）。

配置

要禁用结构化输出测试，请在您的测试类中将 has_structured_output 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_structured_output(self) -> bool:
        return False

默认情况下，如果模型重写了 with_structured_output 或 bind_tools 方法，则 has_structured_output 为 True。

故障排除

如果此测试失败，请确保模型的 bind_tools 方法正确处理 JSON Schema 和 Pydantic V2 模型。

langchain_core 实现了一个工具函数，它将适应大多数格式。

请参阅 with_structured_output 的实现示例。

test_structured_output_async `async` ¶

test_structured_output_async(
    model: BaseChatModel, schema_type: Literal["pydantic", "typeddict", "json_schema"]
) -> None

测试以验证在调用和流上都生成了结构化输出。

此测试是可选的，如果模型不支持结构化输出，则应跳过（参见下面的配置）。

配置

要禁用结构化输出测试，请在您的测试类中将 has_structured_output 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_structured_output(self) -> bool:
        return False

默认情况下，如果模型重写了 with_structured_output 或 bind_tools 方法，则 has_structured_output 为 True。

故障排除

如果此测试失败，请确保模型的 bind_tools 方法正确处理 JSON Schema 和 Pydantic V2 模型。

langchain_core 实现了一个工具函数，它将适应大多数格式。

请参阅 with_structured_output 的实现示例。

test_structured_output_pydantic_2_v1 ¶

test_structured_output_pydantic_2_v1(model: BaseChatModel) -> None

使用 pydantic.v1.BaseModel 测试结构化输出。

验证我们是否可以使用 pydantic.v1.BaseModel 生成结构化输出。

pydantic.v1.BaseModel 在 Pydantic 2 包中可用。

此测试是可选的，如果模型不支持结构化输出，则应跳过（参见下面的配置）。

配置

要禁用结构化输出测试，请在您的测试类中将 has_structured_output 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_structured_output(self) -> bool:
        return False

默认情况下，如果模型重写了 with_structured_output 或 bind_tools 方法，则 has_structured_output 为 True。

故障排除

如果此测试失败，请确保模型的 bind_tools 方法正确处理 JSON Schema 和 Pydantic V1 模型。

langchain_core 实现了一个工具函数，它将适应大多数格式。

请参阅 with_structured_output 的实现示例。

test_structured_output_optional_param ¶

test_structured_output_optional_param(model: BaseChatModel) -> None

测试带可选参数的结构化输出。

测试以验证我们是否可以生成包含可选参数的结构化输出。

此测试是可选的，如果模型不支持结构化输出，则应跳过（参见下面的配置）。

配置

要禁用结构化输出测试，请在您的测试类中将 has_structured_output 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_structured_output(self) -> bool:
        return False

默认情况下，如果模型重写了 with_structured_output 或 bind_tools 方法，则 has_structured_output 为 True。

故障排除

如果此测试失败，请确保模型的 bind_tools 方法正确处理带有可选参数的 Pydantic V2 模型。

langchain_core 实现了一个工具函数，它将适应大多数格式。

请参阅 with_structured_output 的实现示例。

test_json_mode ¶

test_json_mode(model: BaseChatModel) -> None

通过 JSON 模式测试结构化输出。

此测试是可选的，如果模型不支持 JSON 模式功能，则应跳过（参见下面的配置）。

配置

要禁用此测试，请在您的测试类中将 supports_json_mode 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_json_mode(self) -> bool:
        return False

故障排除

请在此处查看 with_structured_output 的实现示例：https://python.langchain.ac.cn/api_reference/_modules/langchain_openai/chat_models/base.html#BaseChatOpenAI.with_structured_output

test_pdf_inputs ¶

test_pdf_inputs(model: BaseChatModel) -> None

测试模型是否可以处理 PDF 输入。

如果模型不支持 PDF 输入，应跳过此测试（参见下面的配置）。这些输入将采用 LangChain FileContentBlock 的形式。

{
    "type": "image",
    "base64": "<base64 image data>",
    "mime_type": "application/pdf",
}

此外，为了向后兼容，我们还必须支持 OpenAI 聊天补全文件内容块。

(
    {
        "type": "file",
        "file": {
            "filename": "test_file.pdf",
            "file_data": f"data:application/pdf;base64,{pdf_data}",
        },
    },
)

配置

要禁用此测试，请在您的测试类中将 supports_pdf_inputs 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_pdf_inputs(self) -> bool:
        return False

故障排除

如果此测试失败，请检查模型是否能正确处理带有 PDF 内容块的消息，包括 base64 编码的文件。否则，请将 supports_pdf_inputs 属性设置为 False。

test_audio_inputs ¶

test_audio_inputs(model: BaseChatModel) -> None

测试模型是否可以处理音频输入。

如果模型不支持音频输入，应跳过此测试（参见下面的配置）。这些输入将采用 LangChain AudioContentBlock 的形式。

{
    "type": "audio",
    "base64": "<base64 audio data>",
    "mime_type": "audio/wav",  # or appropriate MIME type
}

此外，为了向后兼容，我们还必须支持 OpenAI 聊天补全音频内容块。

{
    "type": "input_audio",
    "input_audio": {
        "data": "<base64 audio data>",
        "format": "wav",  # or appropriate format
    },
}

配置

要禁用此测试，请在您的测试类中将 supports_audio_inputs 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_audio_inputs(self) -> bool:
        return False

故障排除

如果此测试失败，请检查模型是否能正确处理带有音频内容块的消息，特别是 base64 编码的文件。否则，请将 supports_audio_inputs 属性设置为 False。

test_image_inputs ¶

test_image_inputs(model: BaseChatModel) -> None

测试模型是否可以处理图像输入。

如果模型不支持图像输入，应跳过此测试（参见下面的配置）。这些输入将采用 LangChain ImageContentBlock 的形式。

{
    "type": "image",
    "base64": "<base64 image data>",
    "mime_type": "image/jpeg",  # or appropriate MIME type
}

为了向后兼容，我们还必须支持包含 base64 编码图像的 OpenAI 聊天补全图像内容块。

[
    {"type": "text", "text": "describe the weather in this image"},
    {
        "type": "image_url",
        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
    },
]

请参阅 https://python.langchain.ac.cn/docs/concepts/multimodality/

如果 supports_image_urls 属性设置为 True，测试还将检查我们是否可以处理以下形式的内容块：

{
    "type": "image",
    "url": "<url>",
}

配置

要禁用此测试，请在您的测试类中将 supports_image_inputs 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_image_inputs(self) -> bool:
        return False

    # Can also explicitly disable testing image URLs:
    @property
    def supports_image_urls(self) -> bool:
        return False

故障排除

如果此测试失败，请检查模型是否能正确处理带有图像内容块的消息，包括 base64 编码的图像。否则，请将 supports_image_inputs 属性设置为 False。

test_image_tool_message ¶

test_image_tool_message(model: BaseChatModel) -> None

测试模型是否可以处理带图像输入的 `ToolMessage` 对象。

如果模型不支持聊天补全 image_url 格式的消息，应跳过此测试。

ToolMessage(
    content=[
        {
            "type": "image_url",
            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
        },
    ],
    tool_call_id="1",
    name="random_image",
)

此外，模型应支持标准的 LangChain ImageContentBlock 格式。

ToolMessage(
    content=[
        {
            "type": "image",
            "base64": image_data,
            "mime_type": "image/jpeg",
        },
    ],
    tool_call_id="1",
    name="random_image",
)

可以通过将 supports_image_tool_message 属性设置为 False 来跳过此测试（参见下面的配置）。

配置

要禁用此测试，请在您的测试类中将 supports_image_tool_message 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_image_tool_message(self) -> bool:
        return False

故障排除

如果此测试失败，请检查模型是否能正确处理 ToolMessage 对象中带有图像内容块的消息，包括 base64 编码的图像。否则，请将 supports_image_tool_message 属性设置为 False。

test_pdf_tool_message ¶

test_pdf_tool_message(model: BaseChatModel) -> None

测试模型是否可以处理带 PDF 输入的 `ToolMessage` 对象。

如果模型不支持 LangChain FileContentBlock 格式的消息，应跳过此测试。

ToolMessage(
    content=[
        {
            "type": "file",
            "base64": pdf_data,
            "mime_type": "application/pdf",
        },
    ],
    tool_call_id="1",
    name="random_pdf",
)

可以通过将 supports_pdf_tool_message 属性设置为 False 来跳过此测试（参见下面的配置）。

配置

要禁用此测试，请在您的测试类中将 supports_pdf_tool_message 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_pdf_tool_message(self) -> bool:
        return False

故障排除

如果此测试失败，请检查模型是否能正确处理 ToolMessage 对象中带有 PDF 内容块的消息，特别是 base64 编码的 PDF。否则，请将 supports_pdf_tool_message 属性设置为 False。

test_anthropic_inputs ¶

test_anthropic_inputs(model: BaseChatModel) -> None

测试模型是否可以处理 Anthropic 风格的消息历史记录。

这些消息历史将包括带有 tool_use 内容块的 AIMessage 对象，例如：

AIMessage(
    [
        {"type": "text", "text": "Hmm let me think about that"},
        {
            "type": "tool_use",
            "input": {"fav_color": "green"},
            "id": "foo",
            "name": "color_picker",
        },
    ]
)

以及包含 tool_result 内容块的 HumanMessage 对象。

HumanMessage(
    [
        {
            "type": "tool_result",
            "tool_use_id": "foo",
            "content": [
                {
                    "type": "text",
                    "text": "green is a great pick! "
                    "that's my sister's favorite color",
                }
            ],
            "is_error": False,
        },
        {"type": "text", "text": "what's my sister's favorite color"},
    ]
)

如果模型不支持此形式的消息（或通常不支持工具调用），应跳过此测试。参见下面的配置。

配置

要禁用此测试，请在您的测试类中将 supports_anthropic_inputs 设置为 False。

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def supports_anthropic_inputs(self) -> bool:
        return False

故障排除

如果此测试失败，请检查

模型能够正确处理包含带有列表内容的消息对象的消息历史。
AIMessage 对象上的 tool_calls 属性被正确处理并以适当的格式传递给模型。
带有“tool_result”内容块的 HumanMessage 被正确处理。

否则，如果不支持 Anthropic 工具调用和结果格式，请将 supports_anthropic_inputs 属性设置为 False。

test_message_with_name ¶

test_message_with_name(model: BaseChatModel) -> None

测试 `name` 字段有值的 `HumanMessage` 是否可以被处理。

这些消息可能采用以下形式：

HumanMessage("hello", name="example_user")

如果可能，应解析 name 字段并适当地传递给模型。否则，应将其忽略。

故障排除

如果此测试失败，请检查 HumanMessage 对象上的 name 字段是被忽略还是被适当地传递给模型。

test_agent_loop ¶

test_agent_loop(model: BaseChatModel) -> None

测试模型是否支持简单的 ReAct 代理循环。

如果测试类上的 `has_tool_calling` 属性设置为 `False`，则跳过此测试。

此测试是可选的，如果模型不支持工具调用，则应跳过（请参阅下面的配置）。

配置

要禁用工具调用测试，请在您的测试类中将 `has_tool_calling` 设置为 False

class TestMyChatModelIntegration(ChatModelIntegrationTests):
    @property
    def has_tool_calling(self) -> bool:
        return False

故障排除

如果此测试失败，请检查 `bind_tools` 是否已实现，以将 LangChain 工具对象正确转换为您的聊天模型的适当模式。

同时检查所有必需信息（例如，工具调用标识符）是否从 AIMessage 对象正确传播到模型负载中。

如果聊天模型在响应适当查询时不能持续生成工具调用，此测试可能会失败。在这些情况下，您可以对测试使用 xfail。

@pytest.mark.xfail(reason=("Does not support tool_choice."))
def test_agent_loop(self, model: BaseChatModel) -> None:
    super().test_agent_loop(model)

test_stream_time ¶

test_stream_time(
    model: BaseChatModel, benchmark: BenchmarkFixture, vcr: Cassette
) -> None

测试流式传输不会引入不必要的开销。

有关更多信息，请参见上方的 <ChatModelIntegrationTests> 下的 enable_vcr_tests 下拉菜单。

配置

可以使用 enable_vcr_tests 属性启用或禁用此测试。例如，要禁用此测试，请将此属性设置为 False。

@property
def enable_vcr_tests(self) -> bool:
    return False

警告

VCR 默认会在磁带中记录身份验证头和其他敏感信息。有关如何配置磁带中记录的信息，请参见上方的 <ChatModelIntegrationTests> 下的 enable_vcr_tests 下拉菜单。

invoke_with_audio_input ¶

invoke_with_audio_input(*, stream: bool = False) -> AIMessage

使用音频输入调用。

invoke_with_audio_output ¶

invoke_with_audio_output(*, stream: bool = False) -> AIMessage

使用音频输出调用。

invoke_with_reasoning_output ¶

invoke_with_reasoning_output(*, stream: bool = False) -> AIMessage

使用推理输出调用。

invoke_with_cache_read_input ¶

invoke_with_cache_read_input(*, stream: bool = False) -> AIMessage

使用缓存读取输入调用。

invoke_with_cache_creation_input ¶

invoke_with_cache_creation_input(*, stream: bool = False) -> AIMessage

使用缓存创建输入调用。

test_unicode_tool_call_integration ¶

test_unicode_tool_call_integration(
    model: BaseChatModel,
    *,
    tool_choice: str | None = None,
    force_tool_call: bool = True,
) -> None

工具调用中 Unicode 字符的通用集成测试。

参数	描述
`model`	要测试的聊天模型类型： `BaseChatModel`
`工具选择`	要传递给 `bind_tools()` 的工具选择参数（特定于提供商）类型: `str \| None` 默认值: `None`
`force_tool_call`	是否强制进行工具调用（如果为 None，则使用 `tool_choice=True`）类型: `bool` 默认值: `True`

测试工具调用参数中的 Unicode 字符是否被正确保留，而不是被转义为 \\uXXXX 序列。

EmbeddingsIntegrationTests ¶

基类：EmbeddingsTests

嵌入集成测试的基类。

测试子类必须实现 embeddings_class 属性以指定要测试的嵌入模型。您也可以覆盖 embedding_model_params 属性以指定初始化参数。

from typing import Type

from langchain_tests.integration_tests import EmbeddingsIntegrationTests
from my_package.embeddings import MyEmbeddingsModel


class TestMyEmbeddingsModelIntegration(EmbeddingsIntegrationTests):
    @property
    def embeddings_class(self) -> Type[MyEmbeddingsModel]:
        # Return the embeddings model class to test here
        return MyEmbeddingsModel

    @property
    def embedding_model_params(self) -> dict:
        # Return initialization parameters for the model.
        return {"model": "model-001"}

注意

单个测试方法的 API 参考包括故障排除提示。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`model`	嵌入模型 fixture。
`test_embed_query`	测试嵌入字符串查询。
`test_embed_documents`	测试嵌入字符串列表。
`test_aembed_query`	测试异步嵌入字符串查询。
`test_aembed_documents`	测试异步嵌入字符串列表。

embeddings_class `abstractmethod` `property` ¶

embeddings_class: type[Embeddings]

嵌入类。

embedding_model_params `property` ¶

embedding_model_params: dict

嵌入模型参数。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

model ¶

model() -> Embeddings

嵌入模型 fixture。

test_embed_query ¶

test_embed_query(model: Embeddings) -> None

测试嵌入字符串查询。

故障排除

如果此测试失败，请检查

当对字符串调用 .embed_query 时，模型将生成一个浮点数列表。
列表的长度在不同输入之间是一致的。

test_embed_documents ¶

test_embed_documents(model: Embeddings) -> None

测试嵌入字符串列表。

故障排除

如果此测试失败，请检查

当对字符串列表调用 .embed_documents 时，模型将生成一个由浮点数列表组成的列表。
每个列表的长度是相同的。

test_aembed_query `async` ¶

test_aembed_query(model: Embeddings) -> None

测试异步嵌入字符串查询。

故障排除

如果此测试失败，请检查

当对字符串调用 .aembed_query 时，模型将生成一个浮点数列表。
列表的长度在不同输入之间是一致的。

test_aembed_documents `async` ¶

test_aembed_documents(model: Embeddings) -> None

测试异步嵌入字符串列表。

故障排除

如果此测试失败，请检查

当对字符串列表调用 .aembed_documents 时，模型将生成一个由浮点数列表组成的列表。
每个列表的长度是相同的。

RetrieversIntegrationTests ¶

基类：BaseStandardTests

检索器集成测试的基类。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`retriever`	返回 retriever fixture。
`test_k_constructor_param`	测试结果数量的构造函数参数。
`test_invoke_with_k_kwarg`	测试 `invoke` 中的结果数量参数。
`test_invoke_returns_documents`	测试 invoke 返回文档。
`test_ainvoke_returns_documents`	测试 ainvoke 返回文档。

retriever_constructor `abstractmethod` `property` ¶

retriever_constructor: type[BaseRetriever]

一个要测试的 BaseRetriever 子类。

retriever_constructor_params `property` ¶

retriever_constructor_params: dict

返回一个要传递给检索器构造函数的参数字典。

retriever_query_example `abstractmethod` `property` ¶

retriever_query_example: str

返回一个表示示例检索器调用中 query 的字符串。

num_results_arg_name `property` ¶

num_results_arg_name: str

返回表示返回结果数量的参数名称。

通常是 k 或 top_k 之类的名称。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

retriever ¶

retriever() -> BaseRetriever

返回 retriever fixture。

test_k_constructor_param ¶

test_k_constructor_param() -> None

测试结果数量的构造函数参数。

测试检索器构造函数是否接受一个表示要返回的文档数量的参数。

默认情况下，测试的参数名为 k，但可以通过设置 num_results_arg_name 属性来覆盖它。

注意

如果检索器不支持通过构造函数配置返回结果的数量，可以使用 pytest 的 xfail 在测试类上跳过此测试。

@pytest.mark.xfail(
    reason="This retriever doesn't support setting "
    "the number of results via the constructor."
)
def test_k_constructor_param(self) -> None:
    raise NotImplementedError

故障排除

如果此测试失败，说明检索器构造函数不接受结果数量参数，或者在设置了 num_results_arg_name 中的参数时，检索器没有返回正确数量的文档。

例如，像这样的检索器：

MyRetriever(k=3).invoke("query")

在用查询调用时应返回 3 个文档。

test_invoke_with_k_kwarg ¶

test_invoke_with_k_kwarg(retriever: BaseRetriever) -> None

测试 invoke 中的结果数量参数。

测试 invoke 方法是否接受一个表示要返回的文档数量的参数。

默认情况下，该参数是有名称的，但可以通过设置 num_results_arg_name 属性来覆盖它。

注意

如果检索器不支持通过 invoke 方法配置返回结果的数量，可以使用 pytest 的 xfail 在测试类上跳过此测试。

@pytest.mark.xfail(
    reason="This retriever doesn't support setting "
    "the number of results in the invoke method."
)
def test_invoke_with_k_kwarg(self) -> None:
    raise NotImplementedError

故障排除

如果此测试失败，说明检索器的 invoke 方法不接受结果数量参数，或者在设置了 num_results_arg_name 中的参数时，检索器没有返回正确数量的文档（k）。

例如，像这样的检索器：

MyRetriever().invoke("query", k=3)

在用查询调用时应返回 3 个文档。

test_invoke_returns_documents ¶

test_invoke_returns_documents(retriever: BaseRetriever) -> None

测试 invoke 返回文档。

如果使用示例参数调用，检索器应返回一个文档列表。

故障排除

如果此测试失败，说明检索器的 invoke 方法没有返回 Document 对象列表。请确认您的 _get_relevant_documents 方法返回的是 Document 对象列表。

test_ainvoke_returns_documents `async` ¶

test_ainvoke_returns_documents(retriever: BaseRetriever) -> None

测试 ainvoke 返回文档。

如果使用示例参数进行 ainvoke 调用，检索器应返回一个文档列表。

有关故障排除的更多信息，请参阅 test_invoke_returns_documents。

ToolsIntegrationTests ¶

基类：ToolsTests

工具集成测试的基类。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`tool`	工具 fixture。
`test_invoke_matches_output_schema`	测试 invoke 是否匹配输出模式。
`test_async_invoke_matches_output_schema`	测试 async invoke 是否匹配输出模式。
`test_invoke_no_tool_call`	测试不带 `ToolCall` 的 invoke。
`test_async_invoke_no_tool_call`	测试不带 `ToolCall` 的 async invoke。

tool_constructor `abstractmethod` `property` ¶

tool_constructor: type[BaseTool] | BaseTool

返回要测试的工具的类或实例。

tool_constructor_params `property` ¶

tool_constructor_params: dict

返回一个要传递给工具构造函数的参数字典。

tool_invoke_params_example `property` ¶

tool_invoke_params_example: dict

返回一个表示示例工具调用“args”的字典。

这不应该是一个 ToolCall 字典——它不应该有 {"name", "id", "args"} 键。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

tool ¶

tool() -> BaseTool

工具 fixture。

test_invoke_matches_output_schema ¶

test_invoke_matches_output_schema(tool: BaseTool) -> None

测试 invoke 是否匹配输出模式。

如果使用 ToolCall 调用，该工具应返回一个有效的 ToolMessage 内容。

如果您遵循了自定义工具指南，此测试应始终通过，因为 ToolCall 输入由 langchain_core.tools.BaseTool 类处理。

如果您没有遵循此指南，您应确保当工具的 invoke 方法接收到一个表示 ToolCall 的字典作为输入时（而不是单独的参数），它会返回一个有效的 ToolMessage 内容。

test_async_invoke_matches_output_schema `async` ¶

test_async_invoke_matches_output_schema(tool: BaseTool) -> None

测试 async invoke 是否匹配输出模式。

如果使用 ToolCall 进行 ainvoke 调用，该工具应返回一个有效的 ToolMessage 内容。

有关调试技巧，请参阅 test_invoke_matches_output_schema。

test_invoke_no_tool_call ¶

test_invoke_no_tool_call(tool: BaseTool) -> None

测试不带 ToolCall 的 invoke。

如果调用时没有 ToolCall，该工具可以返回任何内容，但不应抛出错误。

如果此测试失败，您的工具可能没有正确处理您在 tool_invoke_params_example 中定义的输入，并且正在抛出错误。

此测试没有任何检查。它只是为了确保当使用一个关键字参数字典调用工具时，工具不会抛出错误。

test_async_invoke_no_tool_call `async` ¶

test_async_invoke_no_tool_call(tool: BaseTool) -> None

测试不带 ToolCall 的 async invoke。

如果 ainvoke 调用时没有 ToolCall，该工具可以返回任何内容，但不应抛出错误。

有关调试技巧，请参阅 test_invoke_no_tool_call。

VectorStoreIntegrationTests ¶

基类：BaseStandardTests

向量存储集成测试的基类。

实现者应继承此测试套件，并为每个测试提供一个返回空向量存储的 fixture。

该 fixture 应使用 get_embeddings 方法获取一个预定义的嵌入模型，该模型应在此测试套件中使用。

这是一个模板：

from typing import Generator

import pytest
from langchain_core.vectorstores import VectorStore
from langchain_parrot_link.vectorstores import ParrotVectorStore
from langchain_tests.integration_tests.vectorstores import VectorStoreIntegrationTests


class TestParrotVectorStore(VectorStoreIntegrationTests):
    @pytest.fixture()
    def vectorstore(self) -> Generator[VectorStore, None, None]:  # type: ignore
        """Get an empty vectorstore."""
        store = ParrotVectorStore(self.get_embeddings())
        # note: store should be EMPTY at this point
        # if you need to delete data, you may do so here
        try:
            yield store
        finally:
            # cleanup operations, or deleting data
            pass

在 fixture 中，我们在 yield 之前实例化一个空的向量存储。在 finally 块中，我们调用任何必要的逻辑将向量存储恢复到干净状态。

from typing import Generator

import pytest
from langchain_core.vectorstores import VectorStore
from langchain_tests.integration_tests.vectorstores import VectorStoreIntegrationTests

from langchain_chroma import Chroma


class TestChromaStandard(VectorStoreIntegrationTests):
    @pytest.fixture()
    def vectorstore(self) -> Generator[VectorStore, None, None]:  # type: ignore
        """Get an empty VectorStore for unit tests."""
        store = Chroma(embedding_function=self.get_embeddings())
        try:
            yield store
        finally:
            store.delete_collection()
            pass

请注意，默认情况下，我们同时启用同步和异步测试。要禁用其中任何一个，请在子类中将 has_sync 或 has_async 属性覆盖为 False。例如：

class TestParrotVectorStore(VectorStoreIntegrationTests):
    @pytest.fixture()
    def vectorstore(self) -> Generator[VectorStore, None, None]:  # type: ignore
        ...

    @property
    def has_async(self) -> bool:
        return False

注意

单个测试方法的 API 参考包括故障排除提示。

方法	描述
`test_no_overrides_DO_NOT_OVERRIDE`	测试没有标准测试被覆盖。
`vectorstore`	获取要测试的 VectorStore 类。
`get_embeddings`	获取嵌入。
`test_vectorstore_is_empty`	测试 VectorStore 是否为空。
`test_add_documents`	测试向 `VectorStore` 中添加文档。
`test_vectorstore_still_empty`	测试 VectorStore 是否仍然为空。
`test_deleting_documents`	测试从 `VectorStore` 中删除文档。
`test_deleting_bulk_documents`	测试我们是否可以一次性删除多个文档。
`test_delete_missing_content`	删除缺失的内容不应引发异常。
`test_add_documents_with_ids_is_idempotent`	按 ID 添加应是幂等的。
`test_add_documents_by_id_with_mutation`	测试我们是否可以使用 add_documents 按 ID 进行覆盖。
`test_get_by_ids`	测试按 ID 获取。
`test_get_by_ids_missing`	测试使用缺失的 ID 按 ID 获取。
`test_add_documents_documents`	运行 `add_documents` 测试。
`test_add_documents_with_existing_ids`	测试使用现有 ID 的 `add_documents` 是否是幂等的。
`test_vectorstore_is_empty_async`	测试 VectorStore 是否为空。
`test_add_documents_async`	测试向 `VectorStore` 中添加文档。
`test_vectorstore_still_empty_async`	测试 VectorStore 是否仍然为空。
`test_deleting_documents_async`	测试从 `VectorStore` 中删除文档。
`test_deleting_bulk_documents_async`	测试我们是否可以一次性删除多个文档。
`test_delete_missing_content_async`	删除缺失的内容不应引发异常。
`test_add_documents_with_ids_is_idempotent_async`	按 ID 添加应是幂等的。
`test_add_documents_by_id_with_mutation_async`	测试我们是否可以使用 add_documents 按 ID 进行覆盖。
`test_get_by_ids_async`	测试按 ID 获取。
`test_get_by_ids_missing_async`	测试使用缺失的 ID 按 ID 获取。
`test_add_documents_documents_async`	运行 `add_documents` 测试。
`test_add_documents_with_existing_ids_async`	测试使用现有 ID 的 `add_documents` 是否是幂等的。

has_sync `property` ¶

has_sync: bool

可配置属性，用于启用或禁用同步测试。

has_async `property` ¶

has_async: bool

可配置属性，用于启用或禁用异步测试。

has_get_by_ids `property` ¶

has_get_by_ids: bool

向量存储是否支持 get_by_ids。

test_no_overrides_DO_NOT_OVERRIDE ¶

test_no_overrides_DO_NOT_OVERRIDE() -> None

测试没有标准测试被覆盖。

vectorstore `abstractmethod` ¶

vectorstore() -> VectorStore

获取要测试的 VectorStore 类。

返回的 VectorStore 应为空。

get_embeddings `staticmethod` ¶

get_embeddings() -> Embeddings

获取嵌入。

一个预定义的嵌入模型，应用于此测试。

当前使用来自 langchain-core 的 DeterministicFakeEmbedding，它使用 numpy 根据输入文本的哈希值生成随机数。

生成的嵌入没有实际意义，但它们是确定性的。

test_vectorstore_is_empty ¶

test_vectorstore_is_empty(vectorstore: VectorStore) -> None

测试 VectorStore 是否为空。

故障排除

如果此测试失败，请检查测试类（即 VectorStoreIntegrationTests 的子类）是否在 vectorestore fixture 中初始化了一个空的向量存储。

test_add_documents ¶

test_add_documents(vectorstore: VectorStore) -> None

测试向 VectorStore 中添加文档。

故障排除

如果此测试失败，请检查

我们在 vectorestore fixture 中正确初始化了一个空的向量存储。
调用 .similarity_search 获取前 k 个相似文档时，不按分数进行阈值筛选。
在将原始文档对象添加到向量存储时，我们不会对其进行修改（例如，通过添加 ID）。

test_vectorstore_still_empty ¶

test_vectorstore_still_empty(vectorstore: VectorStore) -> None

测试 VectorStore 是否仍然为空。

此测试应在一个添加了文档的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

故障排除

如果此测试失败，请检查测试类（即 VectorStoreIntegrationTests 的子类）是否在 finally 块中正确清除了向量存储。

test_deleting_documents ¶

test_deleting_documents(vectorstore: VectorStore) -> None

测试从 VectorStore 中删除文档。

故障排除

如果此测试失败，请检查 add_documents 是否保留了通过 ids 传入的标识符，以及 delete 是否正确删除了文档。

test_deleting_bulk_documents ¶

test_deleting_bulk_documents(vectorstore: VectorStore) -> None

测试我们是否可以一次性删除多个文档。

故障排除

如果此测试失败，请检查 delete 在给定 ID 列表时是否能正确删除多个文档。

test_delete_missing_content ¶

test_delete_missing_content(vectorstore: VectorStore) -> None

删除缺失的内容不应引发异常。

故障排除

如果此测试失败，请检查 delete 在删除不存在的 ID 时是否不引发异常。

test_add_documents_with_ids_is_idempotent ¶

test_add_documents_with_ids_is_idempotent(vectorstore: VectorStore) -> None

按 ID 添加应是幂等的。

故障排除

如果此测试失败，请检查使用相同 ID 两次添加相同文档的效果是否与添加一次相同（即，它不会复制文档）。

test_add_documents_by_id_with_mutation ¶

test_add_documents_by_id_with_mutation(vectorstore: VectorStore) -> None

测试我们是否可以使用 add_documents 按 ID 进行覆盖。

故障排除

如果此测试失败，请检查当使用向量存储中已存在的 ID 调用 add_documents 时，内容是更新而不是复制。

test_get_by_ids ¶

test_get_by_ids(vectorstore: VectorStore) -> None

测试按 ID 获取。

此测试要求在向量存储上实现 get_by_ids。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_get_by_ids_missing ¶

test_get_by_ids_missing(vectorstore: VectorStore) -> None

测试使用缺失的 ID 按 ID 获取。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并且在给定不存在的 ID 时不引发异常。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_add_documents_documents ¶

test_add_documents_documents(vectorstore: VectorStore) -> None

运行 add_documents 测试。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

同时检查如果没有提供 ID，add_documents 是否会正确生成字符串 ID。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_add_documents_with_existing_ids ¶

test_add_documents_with_existing_ids(vectorstore: VectorStore) -> None

测试使用现有 ID 的 add_documents 是否是幂等的。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

此测试还验证了：

在添加文档时，会分配 Document.id 字段中指定的 ID。
如果某些文档包含 ID 而其他文档不包含，则会为后者生成字符串 ID。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_vectorstore_is_empty_async `async` ¶

test_vectorstore_is_empty_async(vectorstore: VectorStore) -> None

测试 VectorStore 是否为空。

故障排除

如果此测试失败，请检查测试类（即 VectorStoreIntegrationTests 的子类）是否在 vectorestore fixture 中初始化了一个空的向量存储。

test_add_documents_async `async` ¶

test_add_documents_async(vectorstore: VectorStore) -> None

测试向 VectorStore 中添加文档。

故障排除

如果此测试失败，请检查

我们在 vectorestore fixture 中正确初始化了一个空的向量存储。
调用 .asimilarity_search 获取前 k 个相似文档时，不按分数进行阈值筛选。
在将原始文档对象添加到向量存储时，我们不会对其进行修改（例如，通过添加 ID）。

test_vectorstore_still_empty_async `async` ¶

test_vectorstore_still_empty_async(vectorstore: VectorStore) -> None

测试 VectorStore 是否仍然为空。

此测试应在一个添加了文档的测试之后进行。

这只是为了验证 fixture 是否正确设置为在每个测试后为空。

故障排除

如果此测试失败，请检查测试类（即 VectorStoreIntegrationTests 的子类）是否在 finally 块中正确清除了向量存储。

test_deleting_documents_async `async` ¶

test_deleting_documents_async(vectorstore: VectorStore) -> None

测试从 VectorStore 中删除文档。

故障排除

如果此测试失败，请检查 aadd_documents 是否保留了通过 ids 传入的标识符，以及 delete 是否正确删除了文档。

test_deleting_bulk_documents_async `async` ¶

test_deleting_bulk_documents_async(vectorstore: VectorStore) -> None

测试我们是否可以一次性删除多个文档。

故障排除

如果此测试失败，请检查 adelete 在给定 ID 列表时是否能正确删除多个文档。

test_delete_missing_content_async `async` ¶

test_delete_missing_content_async(vectorstore: VectorStore) -> None

删除缺失的内容不应引发异常。

故障排除

如果此测试失败，请检查 adelete 在删除不存在的 ID 时是否不引发异常。

test_add_documents_with_ids_is_idempotent_async `async` ¶

test_add_documents_with_ids_is_idempotent_async(vectorstore: VectorStore) -> None

按 ID 添加应是幂等的。

故障排除

如果此测试失败，请检查使用相同 ID 两次添加相同文档的效果是否与添加一次相同（即，它不会复制文档）。

test_add_documents_by_id_with_mutation_async `async` ¶

test_add_documents_by_id_with_mutation_async(vectorstore: VectorStore) -> None

测试我们是否可以使用 add_documents 按 ID 进行覆盖。

故障排除

如果此测试失败，请检查当使用向量存储中已存在的 ID 调用 aadd_documents 时，内容是更新而不是复制。

test_get_by_ids_async `async` ¶

test_get_by_ids_async(vectorstore: VectorStore) -> None

测试按 ID 获取。

此测试要求在向量存储上实现 get_by_ids。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_get_by_ids_missing_async `async` ¶

test_get_by_ids_missing_async(vectorstore: VectorStore) -> None

测试使用缺失的 ID 按 ID 获取。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并且在给定不存在的 ID 时不引发异常。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_add_documents_documents_async `async` ¶

test_add_documents_documents_async(vectorstore: VectorStore) -> None

运行 add_documents 测试。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

同时检查如果没有提供 ID，aadd_documents 是否会正确生成字符串 ID。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

test_add_documents_with_existing_ids_async `async` ¶

test_add_documents_with_existing_ids_async(vectorstore: VectorStore) -> None

测试使用现有 ID 的 add_documents 是否是幂等的。

故障排除

如果此测试失败，请检查 get_by_ids 是否已实现，并按传入 ID 的相同顺序返回文档。

此测试还验证了：

在添加文档时，会分配 Document.id 字段中指定的 ID。
如果某些文档包含 ID 而其他文档不包含，则会为后者生成字符串 ID。

注意

get_by_ids 是在 langchain-core 0.2.11 版本中添加到 VectorStore 接口的。如果难以实现，可以通过将 has_get_by_ids 属性设置为 False 来跳过此测试。

@property
def has_get_by_ids(self) -> bool:
    return False

集成测试¶

langchain_tests.integration_tests ¶

BaseStoreAsyncTests ¶

test_no_overrides_DO_NOT_OVERRIDE ¶

kv_store abstractmethod async ¶

three_values abstractmethod ¶

test_three_values async ¶

test_kv_store_is_empty async ¶

test_set_and_get_values async ¶

test_store_still_empty async ¶

test_delete_values async ¶

test_delete_bulk_values async ¶

test_delete_missing_keys async ¶

test_set_values_is_idempotent async ¶

test_get_can_get_same_value async ¶

test_overwrite_values_by_key async ¶

test_yield_keys async ¶

BaseStoreSyncTests ¶

test_no_overrides_DO_NOT_OVERRIDE ¶

kv_store abstractmethod ¶

three_values abstractmethod ¶

test_three_values ¶

test_kv_store_is_empty ¶

test_set_and_get_values ¶

test_store_still_empty ¶

test_delete_values ¶

test_delete_bulk_values ¶

test_delete_missing_keys ¶

test_set_values_is_idempotent ¶

test_get_can_get_same_value ¶

test_overwrite_values_by_key ¶

test_yield_keys ¶

AsyncCacheTestSuite ¶

test_no_overrides_DO_NOT_OVERRIDE ¶

cache abstractmethod async ¶

get_sample_prompt ¶

get_sample_llm_string ¶

get_sample_generation ¶

test_cache_is_empty async ¶

test_update_cache async ¶

test_cache_still_empty async ¶

test_clear_cache async ¶

test_cache_miss async ¶

test_cache_hit async ¶

test_update_cache_with_multiple_generations async ¶

SyncCacheTestSuite ¶

test_no_overrides_DO_NOT_OVERRIDE ¶

cache abstractmethod ¶

get_sample_prompt ¶

get_sample_llm_string ¶

get_sample_generation ¶

test_cache_is_empty ¶

test_update_cache ¶

test_cache_still_empty ¶

test_clear_cache ¶

test_cache_miss ¶

test_cache_hit ¶

test_update_cache_with_multiple_generations ¶

ChatModelIntegrationTests ¶

chat_model_class abstractmethod property ¶

chat_model_params property ¶

has_tool_calling property ¶

tool_choice_value property ¶

has_tool_choice property ¶

has_structured_output property ¶

structured_output_kwargs property ¶

supports_json_mode property ¶

supports_image_inputs property ¶

supports_image_urls property ¶

supports_pdf_inputs property ¶

supports_audio_inputs property ¶

supports_video_inputs property ¶

returns_usage_metadata property ¶

supports_anthropic_inputs property ¶

supports_image_tool_message property ¶

supports_pdf_tool_message property ¶

enable_vcr_tests property ¶

supported_usage_metadata_details property ¶

standard_chat_model_params property ¶

test_no_overrides_DO_NOT_OVERRIDE ¶

kv_store `abstractmethod` `async` ¶

three_values `abstractmethod` ¶

test_three_values `async` ¶

test_kv_store_is_empty `async` ¶

test_set_and_get_values `async` ¶

test_store_still_empty `async` ¶

test_delete_values `async` ¶

test_delete_bulk_values `async` ¶

test_delete_missing_keys `async` ¶

test_set_values_is_idempotent `async` ¶

test_get_can_get_same_value `async` ¶

test_overwrite_values_by_key `async` ¶

test_yield_keys `async` ¶

kv_store `abstractmethod` ¶

three_values `abstractmethod` ¶

cache `abstractmethod` `async` ¶

test_cache_is_empty `async` ¶

test_update_cache `async` ¶

test_cache_still_empty `async` ¶

test_clear_cache `async` ¶

test_cache_miss `async` ¶

test_cache_hit `async` ¶

test_update_cache_with_multiple_generations `async` ¶

cache `abstractmethod` ¶

chat_model_class `abstractmethod` `property` ¶

chat_model_params `property` ¶

has_tool_calling `property` ¶

tool_choice_value `property` ¶

has_tool_choice `property` ¶

has_structured_output `property` ¶

structured_output_kwargs `property` ¶

supports_json_mode `property` ¶

supports_image_inputs `property` ¶

supports_image_urls `property` ¶

supports_pdf_inputs `property` ¶

supports_audio_inputs `property` ¶

supports_video_inputs `property` ¶

returns_usage_metadata `property` ¶

supports_anthropic_inputs `property` ¶

supports_image_tool_message `property` ¶

supports_pdf_tool_message `property` ¶

enable_vcr_tests `property` ¶

supported_usage_metadata_details `property` ¶

standard_chat_model_params `property` ¶

test_ainvoke `async` ¶

test_astream `async` ¶

test_abatch `async` ¶

test_tool_calling_async `async` ¶

test_structured_output_async `async` ¶

embeddings_class `abstractmethod` `property` ¶

embedding_model_params `property` ¶

test_aembed_query `async` ¶

test_aembed_documents `async` ¶

retriever_constructor `abstractmethod` `property` ¶

retriever_constructor_params `property` ¶

retriever_query_example `abstractmethod` `property` ¶

num_results_arg_name `property` ¶

test_ainvoke_returns_documents `async` ¶

tool_constructor `abstractmethod` `property` ¶

tool_constructor_params `property` ¶

tool_invoke_params_example `property` ¶

test_async_invoke_matches_output_schema `async` ¶