nvidia-nat-test 1.2.0__py3-none-any.whl

nat/meta/pypi.md

@@ -0,0 +1,23 @@
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+# NVIDIA NeMo Agent Toolkit Subpackage
+This is a subpackage for NeMo Agent toolkit test utilities.
+
+For more information about the NVIDIA NeMo Agent toolkit, please visit the [NeMo Agent toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nat/test/__init__.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Tool testing utilities
+from .tool_test_runner import ToolTestRunner
+from .tool_test_runner import with_mocked_dependencies
+
+__all__ = [
+    "ToolTestRunner",
+    "with_mocked_dependencies",
+]

nat/test/embedder.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import ConfigDict
+
+from nat.builder.builder import Builder
+from nat.builder.embedder import EmbedderProviderInfo
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_embedder_client
+from nat.cli.register_workflow import register_embedder_provider
+from nat.data_models.embedder import EmbedderBaseConfig
+
+
+class EmbedderTestConfig(EmbedderBaseConfig, name="test_embedder"):
+    model_config = ConfigDict(protected_namespaces=())
+
+    model_name: str = "nvidia/nv-embedqa-e5-v5"
+    embedding_size: int = 768
+
+
+@register_embedder_provider(config_type=EmbedderTestConfig)
+async def embedder_test_provider(config: EmbedderTestConfig, builder: Builder):
+
+    yield EmbedderProviderInfo(config=config, description="Test embedder provider")
+
+
+@register_embedder_client(config_type=EmbedderTestConfig, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+async def embedder_langchain_test_client(config: EmbedderTestConfig, builder: Builder):
+
+    from langchain_community.embeddings import DeterministicFakeEmbedding
+
+    yield DeterministicFakeEmbedding(size=config.embedding_size)

nat/test/functions.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import AsyncGenerator
+
+from nat.builder.builder import Builder
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.api_server import ChatRequest
+from nat.data_models.api_server import ChatResponse
+from nat.data_models.api_server import ChatResponseChunk
+from nat.data_models.function import FunctionBaseConfig
+
+
+class EchoFunctionConfig(FunctionBaseConfig, name="test_echo"):
+    use_openai_api: bool = False
+
+
+@register_function(config_type=EchoFunctionConfig)
+async def echo_function(config: EchoFunctionConfig, builder: Builder):
+
+    async def inner(message: str) -> str:
+        return message
+
+    async def inner_oai(message: ChatRequest) -> ChatResponse:
+        return ChatResponse.from_string(message.messages[0].content)
+
+    if (config.use_openai_api):
+        yield inner_oai
+    else:
+        yield inner
+
+
+class StreamingEchoFunctionConfig(FunctionBaseConfig, name="test_streaming_echo"):
+    use_openai_api: bool = False
+
+
+@register_function(config_type=StreamingEchoFunctionConfig)
+async def streaming_function(config: StreamingEchoFunctionConfig, builder: Builder):
+
+    def oai_to_list(message: ChatRequest) -> list[str]:
+        return [m.content for m in message.messages]
+
+    async def inner(message: list[str]) -> AsyncGenerator[str]:
+        for value in message:
+            yield value
+
+    async def inner_oai(message: ChatRequest) -> AsyncGenerator[ChatResponseChunk]:
+        for value in oai_to_list(message):
+            yield ChatResponseChunk.from_string(value)
+
+    yield FunctionInfo.from_fn(inner_oai if config.use_openai_api else inner, converters=[oai_to_list])
+
+
+class ConstantFunctionConfig(FunctionBaseConfig, name="test_constant"):
+    response: str
+
+
+@register_function(config_type=ConstantFunctionConfig)
+async def constant_function(config: ConstantFunctionConfig, builder: Builder):
+
+    async def inner() -> str:
+        return config.response
+
+    yield inner
+
+
+class StreamingConstantFunctionConfig(FunctionBaseConfig, name="test_streaming_constant"):
+    responses: list[str]
+
+
+@register_function(config_type=StreamingConstantFunctionConfig)
+async def streaming_constant_function(config: StreamingConstantFunctionConfig, builder: Builder):
+
+    async def inner() -> AsyncGenerator[str]:
+        for value in config.responses:
+            yield value
+
+    yield inner

nat/test/memory.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_memory
+from nat.data_models.memory import MemoryBaseConfig
+from nat.memory.interfaces import MemoryEditor
+from nat.memory.models import MemoryItem
+
+
+class DummyMemoryConfig(MemoryBaseConfig, name="test_dummy"):
+    pass
+
+
+@register_memory(config_type=DummyMemoryConfig)
+async def echo_function(config: DummyMemoryConfig, builder: Builder):
+
+    class DummyMemoryEditor(MemoryEditor):
+
+        async def add_items(self, items: list[MemoryItem]) -> None:
+            pass
+
+        async def search(self, query: str, top_k: int = 5, **kwargs) -> list[MemoryItem]:
+            return []
+
+        async def remove_items(self, **kwargs) -> None:
+            pass
+
+    yield DummyMemoryEditor()

nat/test/object_store_tests.py

@@ -0,0 +1,117 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import uuid
+from abc import abstractmethod
+from contextlib import asynccontextmanager
+
+import pytest
+import pytest_asyncio
+
+from nat.data_models.object_store import KeyAlreadyExistsError
+from nat.data_models.object_store import NoSuchKeyError
+from nat.object_store.interfaces import ObjectStore
+from nat.object_store.models import ObjectStoreItem
+
+
+@pytest.mark.asyncio(loop_scope="class")
+class ObjectStoreTests:
+
+    @abstractmethod
+    @asynccontextmanager
+    async def _get_store(self):
+        yield
+
+    @pytest_asyncio.fixture(loop_scope="class", scope="class")
+    async def store(self):
+
+        async with self._get_store() as store:
+            yield store
+
+    async def test_create_object_store(self, store: ObjectStore):
+        assert isinstance(store, ObjectStore)
+
+    async def test_put_object(self, store: ObjectStore):
+
+        # Use a random key to avoid conflicts with other tests
+        key = f"test_key_{uuid.uuid4()}"
+
+        initial_item = ObjectStoreItem(data=b"test_value")
+        await store.put_object(key, initial_item)
+
+        # Try to put the same object again
+        with pytest.raises(KeyAlreadyExistsError):
+            await store.put_object(key, initial_item)
+
+    async def test_upsert_object(self, store: ObjectStore):
+        key = f"test_key_{uuid.uuid4()}"
+
+        initial_item = ObjectStoreItem(data=b"test_value", content_type="text/plain", metadata={"key": "value"})
+
+        await store.upsert_object(key, initial_item)
+
+        # Check that the object exists
+        retrieved_item = await store.get_object(key)
+        assert retrieved_item.data == initial_item.data
+        assert retrieved_item.content_type == initial_item.content_type
+        assert retrieved_item.metadata == initial_item.metadata
+
+        # Upsert the object with a new value
+        new_item = ObjectStoreItem(data=b"new_value", content_type="application/json", metadata={"key": "new_value"})
+        await store.upsert_object(key, new_item)
+
+        # Check that the object was updated
+        retrieved_item = await store.get_object(key)
+        assert retrieved_item.data == new_item.data
+        assert retrieved_item.content_type == new_item.content_type
+        assert retrieved_item.metadata == new_item.metadata
+
+    async def test_get_object(self, store: ObjectStore):
+
+        key = f"test_key_{uuid.uuid4()}"
+
+        initial_item = ObjectStoreItem(data=b"test_value", content_type="text/plain", metadata={"key": "value"})
+        await store.put_object(key, initial_item)
+
+        retrieved_item = await store.get_object(key)
+        assert retrieved_item.data == initial_item.data
+        assert retrieved_item.content_type == initial_item.content_type
+        assert retrieved_item.metadata == initial_item.metadata
+
+        # Try to get an object that doesn't exist
+        with pytest.raises(NoSuchKeyError):
+            await store.get_object(f"test_key_{uuid.uuid4()}")
+
+    async def test_delete_object(self, store: ObjectStore):
+
+        key = f"test_key_{uuid.uuid4()}"
+
+        initial_item = ObjectStoreItem(data=b"test_value")
+        await store.put_object(key, initial_item)
+
+        # Check that the object exists
+        retrieved_item = await store.get_object(key)
+        assert retrieved_item.data == initial_item.data
+
+        # Delete the object
+        await store.delete_object(key)
+
+        # Try to get the object again
+        with pytest.raises(NoSuchKeyError):
+            await store.get_object(key)
+
+        # Try to delete the object again
+        with pytest.raises(NoSuchKeyError):
+            await store.delete_object(key)

nat/test/plugin.py

@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+
+def pytest_addoption(parser: pytest.Parser):
+    """
+    Adds command line options for running specfic tests that are disabled by default
+    """
+    parser.addoption(
+        "--run_e2e",
+        action="store_true",
+        dest="run_e2e",
+        help="Run end to end tests that would otherwise be skipped",
+    )
+
+    parser.addoption(
+        "--run_integration",
+        action="store_true",
+        dest="run_integration",
+        help=("Run integrations tests that would otherwise be skipped. "
+              "This will call out to external services instead of using mocks"),
+    )
+
+    parser.addoption(
+        "--run_slow",
+        action="store_true",
+        dest="run_slow",
+        help="Run end to end tests that would otherwise be skipped",
+    )
+
+
+def pytest_runtest_setup(item):
+    if (not item.config.getoption("--run_e2e")):
+        if (item.get_closest_marker("e2e") is not None):
+            pytest.skip("Skipping end to end tests by default. Use --run_e2e to enable")
+
+    if (not item.config.getoption("--run_integration")):
+        if (item.get_closest_marker("integration") is not None):
+            pytest.skip("Skipping integration tests by default. Use --run_integration to enable")
+
+    if (not item.config.getoption("--run_slow")):
+        if (item.get_closest_marker("slow") is not None):
+            pytest.skip("Skipping slow tests by default. Use --run_slow to enable")
+
+
+@pytest.fixture(name="register_components", scope="session", autouse=True)
+def register_components_fixture():
+    from nat.runtime.loader import PluginTypes
+    from nat.runtime.loader import discover_and_register_plugins
+
+    # Ensure that all components which need to be registered as part of an import are done so. This is necessary
+    # because imports will not be reloaded between tests, so we need to ensure that all components are registered
+    # before any tests are run.
+    discover_and_register_plugins(PluginTypes.ALL)
+
+    # Also import the nat.test.register module to register test-only components
+    import nat.test.register  # pylint: disable=unused-import # noqa: F401
+
+
+@pytest.fixture(name="module_registry", scope="module", autouse=True)
+def module_registry_fixture():
+    """
+    Resets and returns the global type registry for testing
+
+    This gets automatically used at the module level to ensure no state is leaked between modules
+    """
+    from nat.cli.type_registry import GlobalTypeRegistry
+
+    with GlobalTypeRegistry.push() as registry:
+        yield registry
+
+
+@pytest.fixture(name="registry", scope="function", autouse=True)
+def function_registry_fixture():
+    """
+    Resets and returns the global type registry for testing
+
+    This gets automatically used at the function level to ensure no state is leaked between functions
+    """
+    from nat.cli.type_registry import GlobalTypeRegistry
+
+    with GlobalTypeRegistry.push() as registry:
+        yield registry

nat/test/register.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=unused-import
+# flake8: noqa
+# isort:skip_file
+
+# Import any providers which need to be automatically registered here
+
+from . import embedder
+from . import functions
+from . import memory

nat/test/tool_test_runner.py

@@ -0,0 +1,449 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import logging
+import typing
+from contextlib import asynccontextmanager
+from unittest.mock import AsyncMock
+from unittest.mock import MagicMock
+
+from nat.builder.builder import Builder
+from nat.builder.function import Function
+from nat.builder.function_info import FunctionInfo
+from nat.cli.type_registry import GlobalTypeRegistry
+from nat.data_models.function import FunctionBaseConfig
+from nat.data_models.object_store import ObjectStoreBaseConfig
+from nat.object_store.interfaces import ObjectStore
+from nat.runtime.loader import PluginTypes
+from nat.runtime.loader import discover_and_register_plugins
+
+logger = logging.getLogger(__name__)
+
+
+class MockBuilder(Builder):
+    """
+    A lightweight mock builder for tool testing that provides minimal dependencies.
+    """
+
+    def __init__(self):
+        self._functions = {}
+        self._mocks = {}
+
+    def mock_function(self, name: str, mock_response: typing.Any):
+        """Add a mock function that returns a fixed response."""
+        self._mocks[name] = mock_response
+
+    def mock_llm(self, name: str, mock_response: typing.Any):
+        """Add a mock LLM that returns a fixed response."""
+        self._mocks[f"llm_{name}"] = mock_response
+
+    def mock_embedder(self, name: str, mock_response: typing.Any):
+        """Add a mock embedder that returns a fixed response."""
+        self._mocks[f"embedder_{name}"] = mock_response
+
+    def mock_memory_client(self, name: str, mock_response: typing.Any):
+        """Add a mock memory client that returns a fixed response."""
+        self._mocks[f"memory_{name}"] = mock_response
+
+    def mock_retriever(self, name: str, mock_response: typing.Any):
+        """Add a mock retriever that returns a fixed response."""
+        self._mocks[f"retriever_{name}"] = mock_response
+
+    def mock_object_store(self, name: str, mock_response: typing.Any):
+        """Add a mock object store that returns a fixed response."""
+        self._mocks[f"object_store_{name}"] = mock_response
+
+    def mock_ttc_strategy(self, name: str, mock_response: typing.Any):
+        """Add a mock TTC strategy that returns a fixed response."""
+        self._mocks[f"ttc_strategy_{name}"] = mock_response
+
+    async def add_ttc_strategy(self, name: str, config):
+        """Mock implementation (no‑op)."""
+        pass
+
+    async def get_ttc_strategy(self,
+                               strategy_name: str,
+                               pipeline_type: typing.Any = None,
+                               stage_type: typing.Any = None):
+        """Return a mock TTC strategy if one is configured."""
+        key = f"ttc_strategy_{strategy_name}"
+        if key in self._mocks:
+            mock_strategy = MagicMock()
+            # Provide common callable patterns used in tests
+            mock_strategy.invoke = MagicMock(return_value=self._mocks[key])
+            mock_strategy.ainvoke = AsyncMock(return_value=self._mocks[key])
+            return mock_strategy
+        raise ValueError(f"TTC strategy '{strategy_name}' not mocked. Use mock_ttc_strategy() to add it.")
+
+    async def get_ttc_strategy_config(self,
+                                      strategy_name: str,
+                                      pipeline_type: typing.Any = None,
+                                      stage_type: typing.Any = None):
+        """Mock implementation."""
+        pass
+
+    async def add_function(self, name: str, config: FunctionBaseConfig) -> Function:
+        """Mock implementation - not used in tool testing."""
+        raise NotImplementedError("Mock implementation does not support add_function")
+
+    def get_function(self, name: str) -> Function:
+        """Return a mock function if one is configured."""
+        if name in self._mocks:
+            mock_fn = AsyncMock()
+            mock_fn.ainvoke = AsyncMock(return_value=self._mocks[name])
+            return mock_fn
+        raise ValueError(f"Function '{name}' not mocked. Use mock_function() to add it.")
+
+    def get_function_config(self, name: str) -> FunctionBaseConfig:
+        """Mock implementation."""
+        pass
+
+    async def set_workflow(self, config: FunctionBaseConfig) -> Function:
+        """Mock implementation."""
+        pass
+
+    def get_workflow(self) -> Function:
+        """Mock implementation."""
+        pass
+
+    def get_workflow_config(self) -> FunctionBaseConfig:
+        """Mock implementation."""
+        pass
+
+    def get_tool(self, fn_name: str, wrapper_type):
+        """Mock implementation."""
+        pass
+
+    async def add_llm(self, name: str, config):
+        """Mock implementation."""
+        pass
+
+    async def get_llm(self, llm_name: str, wrapper_type):
+        """Return a mock LLM if one is configured."""
+        key = f"llm_{llm_name}"
+        if key in self._mocks:
+            mock_llm = MagicMock()
+            mock_llm.invoke = MagicMock(return_value=self._mocks[key])
+            mock_llm.ainvoke = AsyncMock(return_value=self._mocks[key])
+            return mock_llm
+        raise ValueError(f"LLM '{llm_name}' not mocked. Use mock_llm() to add it.")
+
+    def get_llm_config(self, llm_name: str):
+        """Mock implementation."""
+        pass
+
+    async def add_embedder(self, name: str, config):
+        """Mock implementation."""
+        pass
+
+    async def get_embedder(self, embedder_name: str, wrapper_type):
+        """Return a mock embedder if one is configured."""
+        key = f"embedder_{embedder_name}"
+        if key in self._mocks:
+            mock_embedder = MagicMock()
+            mock_embedder.embed_query = MagicMock(return_value=self._mocks[key])
+            mock_embedder.embed_documents = MagicMock(return_value=self._mocks[key])
+            return mock_embedder
+        raise ValueError(f"Embedder '{embedder_name}' not mocked. Use mock_embedder() to add it.")
+
+    def get_embedder_config(self, embedder_name: str):
+        """Mock implementation."""
+        pass
+
+    async def add_memory_client(self, name: str, config):
+        """Mock implementation."""
+        pass
+
+    def get_memory_client(self, memory_name: str):
+        """Return a mock memory client if one is configured."""
+        key = f"memory_{memory_name}"
+        if key in self._mocks:
+            mock_memory = MagicMock()
+            mock_memory.add = AsyncMock(return_value=self._mocks[key])
+            mock_memory.search = AsyncMock(return_value=self._mocks[key])
+            return mock_memory
+        raise ValueError(f"Memory client '{memory_name}' not mocked. Use mock_memory_client() to add it.")
+
+    def get_memory_client_config(self, memory_name: str):
+        """Mock implementation."""
+        pass
+
+    async def add_retriever(self, name: str, config):
+        """Mock implementation."""
+        pass
+
+    async def get_retriever(self, retriever_name: str, wrapper_type=None):
+        """Return a mock retriever if one is configured."""
+        key = f"retriever_{retriever_name}"
+        if key in self._mocks:
+            mock_retriever = MagicMock()
+            mock_retriever.retrieve = AsyncMock(return_value=self._mocks[key])
+            return mock_retriever
+        raise ValueError(f"Retriever '{retriever_name}' not mocked. Use mock_retriever() to add it.")
+
+    async def get_retriever_config(self, retriever_name: str):
+        """Mock implementation."""
+        pass
+
+    async def add_object_store(self, name: str, config: ObjectStoreBaseConfig):
+        """Mock implementation for object store."""
+        pass
+
+    async def get_object_store_client(self, object_store_name: str) -> ObjectStore:
+        """Return a mock object store client if one is configured."""
+        key = f"object_store_{object_store_name}"
+        if key in self._mocks:
+            mock_object_store = MagicMock()
+            mock_object_store.put_object = AsyncMock(return_value=self._mocks[key])
+            mock_object_store.get_object = AsyncMock(return_value=self._mocks[key])
+            mock_object_store.delete_object = AsyncMock(return_value=self._mocks[key])
+            mock_object_store.list_objects = AsyncMock(return_value=self._mocks[key])
+            return mock_object_store
+        raise ValueError(f"Object store '{object_store_name}' not mocked. Use mock_object_store() to add it.")
+
+    def get_object_store_config(self, object_store_name: str) -> ObjectStoreBaseConfig:
+        """Mock implementation for object store config."""
+        pass
+
+    def get_user_manager(self):
+        """Mock implementation."""
+        mock_user = MagicMock()
+        mock_user.get_id = MagicMock(return_value="test_user")
+        return mock_user
+
+    def get_function_dependencies(self, fn_name: str):
+        """Mock implementation."""
+        pass
+
+
+class ToolTestRunner:
+    """
+    A test runner that enables isolated testing of NAT tools without requiring
+    full workflow setup, LLMs, or complex dependencies.
+
+    Usage:
+        runner = ToolTestRunner()
+
+        # Test a tool with minimal setup
+        result = await runner.test_tool(
+            config_type=MyToolConfig,
+            config_params={"param1": "value1"},
+            input_data="test input"
+        )
+
+        # Test a tool with mocked dependencies
+        async with runner.with_mocks() as mock_builder:
+            mock_builder.mock_llm("my_llm", "mocked response")
+            result = await runner.test_tool(
+                config_type=MyToolConfig,
+                config_params={"llm_name": "my_llm"},
+                input_data="test input"
+            )
+    """
+
+    def __init__(self):
+        self._ensure_plugins_loaded()
+
+    def _ensure_plugins_loaded(self):
+        """Ensure all plugins are loaded for tool registration."""
+        discover_and_register_plugins(PluginTypes.CONFIG_OBJECT)
+
+    async def test_tool(self,
+                        config_type: type[FunctionBaseConfig],
+                        config_params: dict[str, typing.Any] | None = None,
+                        input_data: typing.Any = None,
+                        expected_output: typing.Any = None,
+                        **kwargs) -> typing.Any:
+        """
+        Test a tool in isolation with minimal setup.
+
+        Args:
+            config_type: The tool configuration class
+            config_params: Parameters to pass to the config constructor
+            input_data: Input data to pass to the tool
+            expected_output: Expected output for assertion (optional)
+            **kwargs: Additional parameters
+
+        Returns:
+            The tool's output
+
+        Raises:
+            AssertionError: If expected_output is provided and doesn't match
+            ValueError: If tool registration or execution fails
+        """
+        config_params = config_params or {}
+
+        # Create tool configuration
+        config = config_type(**config_params)
+
+        # Get the registered tool function
+        registry = GlobalTypeRegistry.get()
+        try:
+            tool_registration = registry.get_function(config_type)
+        except KeyError:
+            raise ValueError(
+                f"Tool {config_type} is not registered. Make sure it's imported and registered with @register_function."
+            )
+
+        # Create a mock builder for dependencies
+        mock_builder = MockBuilder()
+
+        # Build the tool function
+        async with tool_registration.build_fn(config, mock_builder) as tool_result:
+
+            # Handle different tool result types
+            if isinstance(tool_result, Function):
+                tool_function = tool_result
+            elif isinstance(tool_result, FunctionInfo):
+                # Extract the actual function from FunctionInfo
+                if tool_result.single_fn:
+                    tool_function = tool_result.single_fn
+                elif tool_result.stream_fn:
+                    tool_function = tool_result.stream_fn
+                else:
+                    raise ValueError("Tool function not found in FunctionInfo")
+            elif callable(tool_result):
+                tool_function = tool_result
+            else:
+                raise ValueError(f"Unexpected tool result type: {type(tool_result)}")
+
+            # Execute the tool
+            if input_data is not None:
+                if asyncio.iscoroutinefunction(tool_function):
+                    result = await tool_function(input_data)
+                else:
+                    result = tool_function(input_data)
+            else:
+                if asyncio.iscoroutinefunction(tool_function):
+                    result = await tool_function()
+                else:
+                    result = tool_function()
+
+            # Assert expected output if provided
+            if expected_output is not None:
+                assert result == expected_output, f"Expected {expected_output}, got {result}"
+
+            return result
+
+    @asynccontextmanager
+    async def with_mocks(self):
+        """
+        Context manager that provides a mock builder for setting up dependencies.
+
+        Usage:
+            async with runner.with_mocks() as mock_builder:
+                mock_builder.mock_llm("my_llm", "mocked response")
+                result = await runner.test_tool_with_builder(
+                    config_type=MyToolConfig,
+                    builder=mock_builder,
+                    input_data="test input"
+                )
+        """
+        mock_builder = MockBuilder()
+        try:
+            yield mock_builder
+        finally:
+            pass
+
+    async def test_tool_with_builder(
+        self,
+        config_type: type[FunctionBaseConfig],
+        builder: MockBuilder,
+        config_params: dict[str, typing.Any] | None = None,
+        input_data: typing.Any = None,
+        expected_output: typing.Any = None,
+    ) -> typing.Any:
+        """
+        Test a tool with a pre-configured mock builder.
+
+        Args:
+            config_type: The tool configuration class
+            builder: Pre-configured MockBuilder with mocked dependencies
+            config_params: Parameters to pass to the config constructor
+            input_data: Input data to pass to the tool
+            expected_output: Expected output for assertion (optional)
+
+        Returns:
+            The tool's output
+        """
+        config_params = config_params or {}
+
+        # Create tool configuration
+        config = config_type(**config_params)
+
+        # Get the registered tool function
+        registry = GlobalTypeRegistry.get()
+        try:
+            tool_registration = registry.get_function(config_type)
+        except KeyError:
+            raise ValueError(
+                f"Tool {config_type} is not registered. Make sure it's imported and registered with @register_function."
+            )
+
+        # Build the tool function with the provided builder
+        async with tool_registration.build_fn(config, builder) as tool_result:
+
+            # Handle different tool result types (same as above)
+            if isinstance(tool_result, Function):
+                tool_function = tool_result
+            elif isinstance(tool_result, FunctionInfo):
+                if tool_result.single_fn:
+                    tool_function = tool_result.single_fn
+                elif tool_result.streaming_fn:
+                    tool_function = tool_result.streaming_fn
+                else:
+                    raise ValueError("Tool function not found in FunctionInfo")
+            elif callable(tool_result):
+                tool_function = tool_result
+            else:
+                raise ValueError(f"Unexpected tool result type: {type(tool_result)}")
+
+            # Execute the tool
+            if input_data is not None:
+                if asyncio.iscoroutinefunction(tool_function):
+                    result = await tool_function(input_data)
+                else:
+                    result = tool_function(input_data)
+            else:
+                if asyncio.iscoroutinefunction(tool_function):
+                    result = await tool_function()
+                else:
+                    result = tool_function()
+
+            # Assert expected output if provided
+            if expected_output is not None:
+                assert result == expected_output, f"Expected {expected_output}, got {result}"
+
+            return result
+
+
+@asynccontextmanager
+async def with_mocked_dependencies():
+    """
+    Convenience context manager for testing tools with mocked dependencies.
+
+    Usage:
+        async with with_mocked_dependencies() as (runner, mock_builder):
+            mock_builder.mock_llm("my_llm", "mocked response")
+            result = await runner.test_tool_with_builder(
+                config_type=MyToolConfig,
+                builder=mock_builder,
+                input_data="test input"
+            )
+    """
+    runner = ToolTestRunner()
+    async with runner.with_mocks() as mock_builder:
+        yield runner, mock_builder

nvidia_nat_test-1.2.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-test
+Version: 1.2.0
+Summary: Testing utilities for NeMo Agent toolkit
+Keywords: ai,rag,agents
+Classifier: Programming Language :: Python
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: nvidia-nat==v1.2.0
+Requires-Dist: langchain-community~=0.3
+Requires-Dist: pytest~=8.3
+
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+# NVIDIA NeMo Agent Toolkit Subpackage
+This is a subpackage for NeMo Agent toolkit test utilities.
+
+For more information about the NVIDIA NeMo Agent toolkit, please visit the [NeMo Agent toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nvidia_nat_test-1.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+nat/meta/pypi.md,sha256=LLKJHg5oN1-M9Pqfk3Bmphkk4O2TFsyiixuK5T0Y-gw,1100
+nat/test/__init__.py,sha256=_RnTJnsUucHvla_nYKqD4O4g8Bz0tcuDRzWk1bEhcy0,875
+nat/test/embedder.py,sha256=ClDyK1kna4hCBSlz71gK1B-ZjlwcBHTDQRekoNM81Bs,1809
+nat/test/functions.py,sha256=0ScrdsjcxCsPRLnyb5gfwukmvZxFi_ptCswLSIG0DVY,3095
+nat/test/memory.py,sha256=xki_A2yiMhEZuQk60K7t04QRqf32nQqnfzD5Iv7fkvw,1456
+nat/test/object_store_tests.py,sha256=PyJioOtoSzILPq6LuD-sOZ_89PIcgXWZweoHBQpK2zQ,4281
+nat/test/plugin.py,sha256=fp39ib0W63vfqX6Ssvq4sCuSd8Lm6yQyknL3_qRijgI,3610
+nat/test/register.py,sha256=jU1pW5wf20ZmCOTgkaQshKZfvYh8_-sMJ4P3xXilfTY,891
+nat/test/tool_test_runner.py,sha256=ccErldob2VwBbVL0_pmLrOcKLc18qYjxeAEACYoKKGQ,17469
+nvidia_nat_test-1.2.0.dist-info/METADATA,sha256=7nR5ymwMR124gv8C6UhR7bVn2vlExEC5UvG9juwZkhY,1448
+nvidia_nat_test-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_test-1.2.0.dist-info/entry_points.txt,sha256=7dOP9XB6iMDqvav3gYx9VWUwA8RrFzhbAa8nGeC8e4Y,99
+nvidia_nat_test-1.2.0.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_test-1.2.0.dist-info/RECORD,,

nvidia_nat_test-1.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nvidia_nat_test-1.2.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[nat.components]
+nvidia-nat-test = nat.test.register
+
+[pytest11]
+nvidia-nat-test = nat.test.plugin

nvidia_nat_test-1.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nat