mseep-agentops 0.4.18__py3-none-any.whl → 0.4.23__py3-none-any.whl

tests/unit/client/test_http_client.py

@@ -1,206 +0,0 @@
-# """Tests for the HttpClient class."""
-#
-# import pytest
-# import requests
-# from unittest import mock
-# from pytest_mock import MockerFixture
-#
-# from agentops.client.http.http_client import HttpClient
-# from agentops.client.http.http_adapter import AuthenticatedHttpAdapter, BaseHTTPAdapter
-# from agentops.client.auth_manager import AuthManager
-#
-#
-# class TestHttpClient:
-#     """Tests for the HttpClient class."""
-#
-#     def test_get_session_creates_new_session_if_none_exists(self):
-#         """Test that get_session creates a new session if none exists."""
-#         # Reset the session to ensure we're testing from a clean state
-#         HttpClient._session = None
-#
-#         # Call get_session
-#         session = HttpClient.get_session()
-#
-#         # Verify a session was created
-#         assert session is not None
-#         assert isinstance(session, requests.Session)
-#
-#         # Verify the session has the expected adapters
-#         assert any(isinstance(adapter, BaseHTTPAdapter) for adapter in session.adapters.values())
-#
-#         # Verify the session has the expected headers
-#         assert "Content-Type" in session.headers
-#         assert "Connection" in session.headers
-#         assert "Keep-Alive" in session.headers
-#
-#     def test_get_session_returns_existing_session(self):
-#         """Test that get_session returns the existing session if one exists."""
-#         # Create a session
-#         HttpClient._session = None
-#         session1 = HttpClient.get_session()
-#
-#         # Call get_session again
-#         session2 = HttpClient.get_session()
-#
-#         # Verify the same session was returned
-#         assert session2 is session1
-#
-#     def test_get_authenticated_session_creates_new_session(self):
-#         """Test that get_authenticated_session creates a new authenticated session."""
-#         # Call get_authenticated_session
-#         session = HttpClient.get_authenticated_session(
-#             endpoint="https://api.example.com",
-#             api_key="test-api-key"
-#         )
-#
-#         # Verify a session was created
-#         assert session is not None
-#         assert isinstance(session, requests.Session)
-#
-#         # Verify the session has the expected adapters
-#         assert any(isinstance(adapter, AuthenticatedHttpAdapter) for adapter in session.adapters.values())
-#
-#         # Verify the session has the expected headers
-#         assert "Content-Type" in session.headers
-#         assert "Connection" in session.headers
-#         assert "Keep-Alive" in session.headers
-#
-#     def test_get_authenticated_session_with_custom_token_fetcher(self, mocker: MockerFixture):
-#         """Test that get_authenticated_session accepts a custom token fetcher."""
-#         # Create a mock token fetcher
-#         mock_token_fetcher = mock.Mock(return_value="test-token")
-#
-#         # Call get_authenticated_session with the custom token fetcher
-#         session = HttpClient.get_authenticated_session(
-#             endpoint="https://api.example.com",
-#             api_key="test-api-key",
-#             token_fetcher=mock_token_fetcher
-#         )
-#
-#         # Verify a session was created
-#         assert session is not None
-#         assert isinstance(session, requests.Session)
-#
-#         # Get the adapter
-#         adapter = next(adapter for adapter in session.adapters.values()
-#                       if isinstance(adapter, AuthenticatedHttpAdapter))
-#
-#         # Verify the adapter has the custom token fetcher
-#         assert adapter.token_fetcher is mock_token_fetcher
-#
-#     def test_request_get(self, mocker: MockerFixture):
-#         """Test that request makes a GET request."""
-#         # Mock the session
-#         mock_session = mock.Mock()
-#         mock_get = mock.Mock()
-#         mock_session.get = mock_get
-#
-#         # Mock get_session to return our mock session
-#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
-#
-#         # Call request
-#         HttpClient.request(
-#             method="get",
-#             url="https://api.example.com/test",
-#             headers={"X-Test": "test"},
-#             timeout=10
-#         )
-#
-#         # Verify the session method was called with the expected arguments
-#         mock_get.assert_called_once_with(
-#             "https://api.example.com/test",
-#             headers={"X-Test": "test"},
-#             timeout=10,
-#             allow_redirects=False
-#         )
-#
-#     def test_request_post(self, mocker: MockerFixture):
-#         """Test that request makes a POST request."""
-#         # Mock the session
-#         mock_session = mock.Mock()
-#         mock_post = mock.Mock()
-#         mock_session.post = mock_post
-#
-#         # Mock get_session to return our mock session
-#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
-#
-#         # Call request
-#         HttpClient.request(
-#             method="post",
-#             url="https://api.example.com/test",
-#             data={"test": "data"},
-#             headers={"X-Test": "test"},
-#             timeout=10
-#         )
-#
-#         # Verify the session method was called with the expected arguments
-#         mock_post.assert_called_once_with(
-#             "https://api.example.com/test",
-#             json={"test": "data"},
-#             headers={"X-Test": "test"},
-#             timeout=10,
-#             allow_redirects=False
-#         )
-#
-#     def test_request_put(self, mocker: MockerFixture):
-#         """Test that request makes a PUT request."""
-#         # Mock the session
-#         mock_session = mock.Mock()
-#         mock_put = mock.Mock()
-#         mock_session.put = mock_put
-#
-#         # Mock get_session to return our mock session
-#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
-#
-#         # Call request
-#         HttpClient.request(
-#             method="put",
-#             url="https://api.example.com/test",
-#             data={"test": "data"},
-#             headers={"X-Test": "test"},
-#             timeout=10
-#         )
-#
-#         # Verify the session method was called with the expected arguments
-#         mock_put.assert_called_once_with(
-#             "https://api.example.com/test",
-#             json={"test": "data"},
-#             headers={"X-Test": "test"},
-#             timeout=10,
-#             allow_redirects=False
-#         )
-#
-#     def test_request_delete(self, mocker: MockerFixture):
-#         """Test that request makes a DELETE request."""
-#         # Mock the session
-#         mock_session = mock.Mock()
-#         mock_delete = mock.Mock()
-#         mock_session.delete = mock_delete
-#
-#         # Mock get_session to return our mock session
-#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
-#
-#         # Call request
-#         HttpClient.request(
-#             method="delete",
-#             url="https://api.example.com/test",
-#             headers={"X-Test": "test"},
-#             timeout=10
-#         )
-#
-#         # Verify the session method was called with the expected arguments
-#         mock_delete.assert_called_once_with(
-#             "https://api.example.com/test",
-#             headers={"X-Test": "test"},
-#             timeout=10,
-#             allow_redirects=False
-#         )
-#
-#     def test_request_unsupported_method(self):
-#         """Test that request raises an error for unsupported methods."""
-#         # Call request with an unsupported method
-#         with pytest.raises(ValueError, match="Unsupported HTTP method: patch"):
-#             HttpClient.request(
-#                 method="patch",
-#                 url="https://api.example.com/test"
-#             )

tests/unit/conftest.py

@@ -1,54 +0,0 @@
-import uuid
-
-import pytest
-import requests_mock
-
-from agentops.config import Config
-from tests.fixtures.client import *  # noqa
-from tests.unit.sdk.instrumentation_tester import InstrumentationTester
-
-
-@pytest.fixture
-def api_key() -> str:
-    """Standard API key for testing"""
-    return "test-api-key"
-
-
-@pytest.fixture
-def endpoint() -> str:
-    """Base API URL"""
-    return Config().endpoint
-
-
-@pytest.fixture(autouse=True)
-def mock_req(endpoint, api_key):
-    """
-    Mocks AgentOps backend API requests.
-    """
-    with requests_mock.Mocker(real_http=False) as m:
-        # Map session IDs to their JWTs
-        m.post(
-            endpoint + "/v3/auth/token",
-            json={"token": str(uuid.uuid4()), "project_id": "test-project-id", "api_key": api_key},
-        )
-        yield m
-
-
-@pytest.fixture
-def noinstrument():
-    # Tells the client to not instrument LLM calls
-    yield
-
-
-@pytest.fixture
-def mock_config(mocker):
-    """Mock the Client.configure method"""
-    return mocker.patch("agentops.client.Client.configure")
-
-
-@pytest.fixture
-def instrumentation():
-    """Fixture for the instrumentation tester."""
-    tester = InstrumentationTester()
-    yield tester
-    tester.reset()

tests/unit/sdk/__init__.py

@@ -1 +0,0 @@
-# Test package for the SDK

tests/unit/sdk/instrumentation_tester.py

@@ -1,207 +0,0 @@
-from typing import Any, Dict, List, Protocol, Tuple, Union
-import importlib
-import unittest.mock as mock
-
-from opentelemetry import trace as trace_api
-from opentelemetry.sdk.trace import ReadableSpan, Span, TracerProvider
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
-from opentelemetry.util.types import Attributes
-
-from agentops.sdk.core import tracer
-
-
-def create_tracer_provider(
-    **kwargs,
-) -> Tuple[TracerProvider, InMemorySpanExporter, SimpleSpanProcessor]:
-    """Helper to create a configured tracer provider.
-
-    Creates and configures a `TracerProvider` with a
-    `SimpleSpanProcessor` and a `InMemorySpanExporter`.
-    All the parameters passed are forwarded to the TracerProvider
-    constructor.
-
-    Returns:
-        A tuple with the tracer provider, memory exporter, and span processor.
-    """
-    tracer_provider = TracerProvider(**kwargs)
-    memory_exporter = InMemorySpanExporter()
-
-    # Use SimpleSpanProcessor instead of both processors to avoid duplication
-    span_processor = SimpleSpanProcessor(memory_exporter)
-    tracer_provider.add_span_processor(span_processor)
-
-    return tracer_provider, memory_exporter, span_processor
-
-
-def reset_trace_globals():
-    """Reset the global trace state to avoid conflicts."""
-    # Reset tracer provider
-    trace_api._TRACER_PROVIDER = None
-
-    # Reload the trace module to clear warning state
-    importlib.reload(trace_api)
-
-
-class HasAttributesViaProperty(Protocol):
-    @property
-    def attributes(self) -> Attributes:
-        ...
-
-
-class HasAttributesViaAttr(Protocol):
-    attributes: Attributes
-
-
-HasAttributes = Union[HasAttributesViaProperty, HasAttributesViaAttr]
-
-
-class InstrumentationTester:
-    """
-    A utility class for testing instrumentation in the AgentOps SDK.
-
-    This class provides methods for setting up a test environment with
-    in-memory span exporters, and for asserting properties of spans.
-    """
-
-    tracer_provider: TracerProvider
-    memory_exporter: InMemorySpanExporter
-    span_processor: SimpleSpanProcessor
-
-    def __init__(self):
-        """Initialize the instrumentation tester."""
-        # Reset any global state first
-        reset_trace_globals()
-
-        # Shut down any existing tracing core
-        # self._shutdown_core()
-
-        # Create a new tracer provider and memory exporter
-        (
-            self.tracer_provider,
-            self.memory_exporter,
-            self.span_processor,
-        ) = create_tracer_provider()
-
-        # Set the tracer provider
-        trace_api.set_tracer_provider(self.tracer_provider)
-
-        # Create a mock for the meter provider
-        self.mock_meter_provider = mock.MagicMock()
-
-        # Patch the setup_telemetry function to return our test providers
-        self.setup_telemetry_patcher = mock.patch(
-            "agentops.sdk.core.setup_telemetry", return_value=(self.tracer_provider, self.mock_meter_provider)
-        )
-        self.mock_setup_telemetry = self.setup_telemetry_patcher.start()
-
-        # Reset the tracing core to force reinitialization
-        core = tracer
-        core._initialized = False
-        core._provider = None
-
-        # Initialize the core, which will now use our mocked setup_telemetry
-        core.initialize()
-
-        self.clear_spans()
-
-    def _shutdown_core(self):
-        """Safely shut down the tracing core."""
-        try:
-            tracer.shutdown()
-        except Exception as e:
-            print(f"Warning: Error shutting down tracing core: {e}")
-
-    def clear_spans(self):
-        """Clear all spans from the memory exporter."""
-        # Force flush spans
-        self.span_processor.force_flush()
-
-        # Then clear the memory
-        self.memory_exporter.clear()
-        print("Cleared all spans from memory exporter")
-
-    def reset(self):
-        """Reset the instrumentation tester."""
-        # Force flush any pending spans
-        self.span_processor.force_flush()
-
-        # Clear any existing spans
-        self.clear_spans()
-
-        # Reset global trace state
-        reset_trace_globals()
-
-        # Set our tracer provider again
-        trace_api.set_tracer_provider(self.tracer_provider)
-
-        # Shut down and re-initialize the tracing core
-        self._shutdown_core()
-
-        # Reset the mock setup_telemetry function
-        self.mock_setup_telemetry.reset_mock()
-
-        # Reset the tracing core to force reinitialization
-        core = tracer
-        core._initialized = False
-        core._provider = None
-
-        # Initialize the core, which will now use our mocked setup_telemetry
-        core.initialize()
-
-    def __del__(self):
-        """Clean up resources when the tester is garbage collected."""
-        try:
-            # Stop the patcher when the tester is deleted
-            self.setup_telemetry_patcher.stop()
-        except Exception:
-            pass
-
-    def get_finished_spans(self) -> List[ReadableSpan]:
-        """Get all finished spans."""
-        # Force flush any pending spans
-        self.span_processor.force_flush()
-
-        # Get the spans
-        spans = list(self.memory_exporter.get_finished_spans())
-        print(f"Instrumentation Tester: Found {len(spans)} finished spans")
-        for i, span in enumerate(spans):
-            print(f"Span {i}: name={span.name}, attributes={span.attributes}")
-        return spans
-
-    def get_spans_by_name(self, name: str) -> List[ReadableSpan]:
-        """Get all spans with the given name."""
-        return [span for span in self.get_finished_spans() if span.name == name]
-
-    def get_spans_by_kind(self, kind: str) -> List[ReadableSpan]:
-        """Get all spans with the given kind."""
-        return [
-            span for span in self.get_finished_spans() if span.attributes and span.attributes.get("span.kind") == kind
-        ]
-
-    @staticmethod
-    def assert_has_attributes(obj: HasAttributes, attributes: Dict[str, Any]):
-        """Assert that an object has the given attributes."""
-        import json
-
-        assert obj.attributes is not None
-        for key, val in attributes.items():
-            assert key in obj.attributes, f"Key {key!r} not found in attributes"
-
-            actual_val = obj.attributes[key]
-
-            # Try to handle JSON-serialized values
-            if isinstance(actual_val, str) and isinstance(val, (list, dict)):
-                try:
-                    actual_val = json.loads(actual_val)
-                except json.JSONDecodeError:
-                    pass
-
-            assert actual_val == val, f"Value for key {key!r} does not match: {actual_val} != {val}"
-
-    @staticmethod
-    def assert_span_instrumented_for(span: Union[Span, ReadableSpan], module):
-        """Assert that a span is instrumented for the given module."""
-        assert span.instrumentation_scope is not None
-        assert span.instrumentation_scope.name == module.__name__
-        assert span.instrumentation_scope.version == module.__version__