Skip to content

Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI

15.9 KB
Raw Blame
from datetime import datetime, timedelta, timezone
from unittest.mock import patch

from agentops.common.freeplan import FreePlanFilteredResponse, freeplan_clamp_datetime, freeplan_clamp_start_time, freeplan_clamp_end_time


class SimpleResponse(FreePlanFilteredResponse):
    _freeplan_exclude = ('field1', 'field2')

    field1: str
    field2: int
    field3: str


class NestedResponse(FreePlanFilteredResponse):
    regular_field: str
    nested_field: SimpleResponse


class MaxLinesResponse(FreePlanFilteredResponse):
    _freeplan_maxlines = {'multiline_field': 3}

    multiline_field: str
    regular_field: str


class MaxItemsResponse(FreePlanFilteredResponse):
    _freeplan_maxitems = {'list_field': 3}

    list_field: list[str]
    regular_field: str


class CombinedResponse(FreePlanFilteredResponse):
    _freeplan_exclude = ('excluded_field',)
    _freeplan_maxlines = {'multiline_field': 2}
    _freeplan_maxitems = {'list_field': 2}

    excluded_field: str
    multiline_field: str
    list_field: list[str]
    regular_field: str


def test_freeplan_exclude():
    """Test that fields listed in _freeplan_exclude are excluded when freeplan_truncated is True."""
    response = SimpleResponse(field1="value1", field2=123, field3="value3")

    # When freeplan_truncated is False, all fields should be included
    response.freeplan_truncated = False
    result = response.model_dump()
    assert result == {
        "field1": "value1",
        "field2": 123,
        "field3": "value3",
        "freeplan_truncated": False,
    }

    # When freeplan_truncated is True, excluded fields should be empty
    response.freeplan_truncated = True
    result = response.model_dump()
    assert result == {
        "field1": "",  # String fields become empty strings
        "field2": 0,  # Int fields become 0
        "field3": "value3",
        "freeplan_truncated": True,
    }


def test_nested_models():
    """Test that nested models are handled correctly."""
    nested = SimpleResponse(field1="nested1", field2=456, field3="nested3")
    response = NestedResponse(regular_field="regular", nested_field=nested)

    # When freeplan_truncated is False, all fields should be included
    response.freeplan_truncated = False
    result = response.model_dump()
    assert result == {
        "regular_field": "regular",
        "nested_field": {
            "field1": "nested1",
            "field2": 456,
            "field3": "nested3",
            "freeplan_truncated": False,
        },
        "freeplan_truncated": False,
    }

    # When freeplan_truncated is True on both the parent and nested model,
    # the nested model should apply its own filtering rules
    response.freeplan_truncated = True
    response.nested_field.freeplan_truncated = True
    result = response.model_dump()

    assert result["regular_field"] == "regular"
    assert result["freeplan_truncated"] == True
    assert "nested_field" in result

    # The nested field should have its own fields filtered according to its rules
    assert result["nested_field"]["field1"] == ""
    assert result["nested_field"]["field2"] == 0
    assert result["nested_field"]["field3"] == "nested3"
    assert result["nested_field"]["freeplan_truncated"] == True


def test_maxlines_truncation():
    """Test that fields listed in _freeplan_maxlines are truncated when freeplan_truncated is True."""
    multiline_text = "line1\nline2\nline3\nline4\nline5"
    response = MaxLinesResponse(multiline_field=multiline_text, regular_field="regular")

    # When freeplan_truncated is False, all lines should be included
    response.freeplan_truncated = False
    result = response.model_dump()
    assert result == {
        "multiline_field": multiline_text,
        "regular_field": "regular",
        "freeplan_truncated": False,
    }

    # When freeplan_truncated is True, multiline field should be truncated to max_lines
    response.freeplan_truncated = True
    result = response.model_dump()
    assert result == {
        "multiline_field": "line1\nline2\nline3",  # Only first 3 lines
        "regular_field": "regular",
        "freeplan_truncated": True,
    }


def test_maxitems_truncation():
    """Test that fields listed in _freeplan_maxitems are truncated when freeplan_truncated is True."""
    test_list = ["item1", "item2", "item3", "item4", "item5"]
    response = MaxItemsResponse(list_field=test_list, regular_field="regular")

    # When freeplan_truncated is False, all items should be included
    response.freeplan_truncated = False
    result = response.model_dump()
    assert result == {
        "list_field": test_list,
        "regular_field": "regular",
        "freeplan_truncated": False,
    }

    # When freeplan_truncated is True, list field should be truncated to max_items
    response.freeplan_truncated = True
    result = response.model_dump()
    assert result == {
        "list_field": ["item1", "item2", "item3"],  # Only first 3 items
        "regular_field": "regular",
        "freeplan_truncated": True,
    }


def test_combined_exclude_maxlines_and_maxitems():
    """Test that exclude, maxlines, and maxitems features all work together."""
    multiline_text = "line1\nline2\nline3\nline4"
    test_list = ["item1", "item2", "item3", "item4"]
    response = CombinedResponse(
        excluded_field="excluded", 
        multiline_field=multiline_text, 
        list_field=test_list,
        regular_field="regular"
    )

    # When freeplan_truncated is True, excluded fields should be empty,
    # multiline fields should be truncated, and list fields should be truncated
    response.freeplan_truncated = True
    result = response.model_dump()
    assert result == {
        "excluded_field": "",  # Excluded field
        "multiline_field": "line1\nline2",  # Truncated to 2 lines
        "list_field": ["item1", "item2"],  # Truncated to 2 items
        "regular_field": "regular",
        "freeplan_truncated": True,
    }


class TestFreePlanClampDatetime:
    """Tests for the freeplan_clamp_datetime function."""

    def test_date_before_cutoff(self):
        """Test that dates before the cutoff are returned as is."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30  # Stand-in value for tests
        # Test date older than cutoff (further in the past)
        old_date = now - timedelta(days=days_cutoff + 10)

        # When date is before cutoff (older), it should return the cutoff date
        result = freeplan_clamp_datetime(old_date, days_cutoff)
        expected = now - timedelta(days=days_cutoff)

        # Verify the result is within a small tolerance of the expected value
        # (to account for tiny time differences during test execution)
        assert abs((result - expected).total_seconds()) < 1

    def test_date_after_cutoff(self):
        """Test that dates after the cutoff are returned as is."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30  # Stand-in value for tests
        # Test date newer than cutoff (more recent)
        recent_date = now - timedelta(days=days_cutoff - 5)

        # When date is after cutoff (newer), it should return the original date
        result = freeplan_clamp_datetime(recent_date, days_cutoff)

        # Should return the original date, not the cutoff
        assert result == recent_date

    def test_date_at_cutoff(self):
        """Test that dates exactly at the cutoff are returned as is."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30  # Stand-in value for tests
        cutoff_date = now - timedelta(days=days_cutoff)

        result = freeplan_clamp_datetime(cutoff_date, days_cutoff)

        # Should return the exact cutoff date (allowing for microsecond differences)
        assert abs((result - cutoff_date).total_seconds()) < 0.001

    @patch('agentops.common.freeplan.datetime')
    def test_with_mocked_time(self, mock_datetime):
        """Test with a mocked current time to ensure reliable comparison."""
        # Fix the current time
        fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc)
        mock_datetime.now.return_value = fixed_now

        # Set cutoff days to 30 for this test
        cutoff_days = 30
        # Expected cutoff date
        cutoff = fixed_now - timedelta(days=cutoff_days)

        # Test with date before cutoff (older)
        old_date = fixed_now - timedelta(days=cutoff_days + 10)
        assert freeplan_clamp_datetime(old_date, cutoff_days) == cutoff

        # Test with date after cutoff (newer)
        recent_date = fixed_now - timedelta(days=cutoff_days - 10)
        assert freeplan_clamp_datetime(recent_date, cutoff_days) == recent_date


class TestFreePlanClampStartTime:
    """Tests for the freeplan_clamp_start_time function."""

    def test_start_time_is_none(self):
        """Test that None start_time returns cutoff and modified=True."""
        days_cutoff = 30
        result, modified = freeplan_clamp_start_time(None, days_cutoff)
        
        # Should return cutoff datetime
        expected_cutoff = datetime.now(timezone.utc) - timedelta(days=days_cutoff)
        assert abs((result - expected_cutoff).total_seconds()) < 1
        
        # Should be marked as modified since None was converted to cutoff
        assert modified is True

    def test_start_time_before_cutoff(self):
        """Test that start_time before cutoff is clamped and modified=True."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        # Date older than cutoff (further in the past)
        old_start_time = now - timedelta(days=days_cutoff + 10)
        
        result, modified = freeplan_clamp_start_time(old_start_time, days_cutoff)
        
        # Should return cutoff, not the original old date
        expected_cutoff = now - timedelta(days=days_cutoff)
        assert abs((result - expected_cutoff).total_seconds()) < 1
        
        # Should be marked as modified since it was clamped
        assert modified is True

    def test_start_time_after_cutoff(self):
        """Test that start_time after cutoff is not clamped and modified=False."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        # Date newer than cutoff (more recent)
        recent_start_time = now - timedelta(days=days_cutoff - 5)
        
        result, modified = freeplan_clamp_start_time(recent_start_time, days_cutoff)
        
        # Should return the original date unchanged
        assert result == recent_start_time
        
        # Should not be marked as modified since no clamping occurred
        assert modified is False

    def test_start_time_at_cutoff(self):
        """Test that start_time exactly at cutoff is not modified."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        cutoff_start_time = now - timedelta(days=days_cutoff)
        
        result, modified = freeplan_clamp_start_time(cutoff_start_time, days_cutoff)
        
        # Should return a date very close to the cutoff date (allowing for timing differences)
        assert abs((result - cutoff_start_time).total_seconds()) < 1
        
        # The timing precision issue means this might be marked as modified due to microsecond differences
        # So we'll accept either outcome for this edge case
        assert modified in [True, False]

    @patch('agentops.common.freeplan.datetime')
    def test_start_time_with_mocked_time(self, mock_datetime):
        """Test start_time with mocked current time for reliable comparison."""
        # Fix the current time
        fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc)
        mock_datetime.now.return_value = fixed_now
        
        cutoff_days = 30
        cutoff = fixed_now - timedelta(days=cutoff_days)
        
        # Test None case
        result, modified = freeplan_clamp_start_time(None, cutoff_days)
        assert result == cutoff
        assert modified is True
        
        # Test old date case
        old_date = fixed_now - timedelta(days=cutoff_days + 5)
        result, modified = freeplan_clamp_start_time(old_date, cutoff_days)
        assert result == cutoff
        assert modified is True
        
        # Test recent date case
        recent_date = fixed_now - timedelta(days=cutoff_days - 5)
        result, modified = freeplan_clamp_start_time(recent_date, cutoff_days)
        assert result == recent_date
        assert modified is False


class TestFreePlanClampEndTime:
    """Tests for the freeplan_clamp_end_time function."""

    def test_end_time_is_none(self):
        """Test that None end_time returns current time and modified=True."""
        days_cutoff = 30
        
        # Capture current time before the call
        before_call = datetime.now(timezone.utc)
        result, modified = freeplan_clamp_end_time(None, days_cutoff)
        after_call = datetime.now(timezone.utc)
        
        # Should return current time (within reasonable bounds)
        assert before_call <= result <= after_call
        
        # Should be marked as modified since None was converted to current time
        assert modified is True

    def test_end_time_before_cutoff(self):
        """Test that end_time before cutoff is clamped and modified=True."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        # Date older than cutoff (further in the past)
        old_end_time = now - timedelta(days=days_cutoff + 10)
        
        result, modified = freeplan_clamp_end_time(old_end_time, days_cutoff)
        
        # Should return cutoff, not the original old date
        expected_cutoff = now - timedelta(days=days_cutoff)
        assert abs((result - expected_cutoff).total_seconds()) < 1
        
        # Should be marked as modified since it was clamped
        assert modified is True

    def test_end_time_after_cutoff(self):
        """Test that end_time after cutoff is not clamped and modified=False."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        # Date newer than cutoff (more recent)
        recent_end_time = now - timedelta(days=days_cutoff - 5)
        
        result, modified = freeplan_clamp_end_time(recent_end_time, days_cutoff)
        
        # Should return the original date unchanged
        assert result == recent_end_time
        
        # Should not be marked as modified since no clamping occurred
        assert modified is False

    def test_end_time_at_cutoff(self):
        """Test that end_time exactly at cutoff is not modified."""
        now = datetime.now(timezone.utc)
        days_cutoff = 30
        cutoff_end_time = now - timedelta(days=days_cutoff)
        
        result, modified = freeplan_clamp_end_time(cutoff_end_time, days_cutoff)
        
        # Should return a date very close to the cutoff date (allowing for timing differences)
        assert abs((result - cutoff_end_time).total_seconds()) < 1
        
        # The timing precision issue means this might be marked as modified due to microsecond differences
        # So we'll accept either outcome for this edge case
        assert modified in [True, False]

    @patch('agentops.common.freeplan.datetime')
    def test_end_time_with_mocked_time(self, mock_datetime):
        """Test end_time with mocked current time for reliable comparison."""
        # Fix the current time
        fixed_now = datetime(2023, 1, 15, tzinfo=timezone.utc)
        mock_datetime.now.return_value = fixed_now
        
        cutoff_days = 30
        cutoff = fixed_now - timedelta(days=cutoff_days)
        
        # Test None case - should return current time
        result, modified = freeplan_clamp_end_time(None, cutoff_days)
        assert result == fixed_now
        assert modified is True
        
        # Test old date case - should be clamped to cutoff
        old_date = fixed_now - timedelta(days=cutoff_days + 5)
        result, modified = freeplan_clamp_end_time(old_date, cutoff_days)
        assert result == cutoff
        assert modified is True
        
        # Test recent date case - should not be clamped
        recent_date = fixed_now - timedelta(days=cutoff_days - 5)
        result, modified = freeplan_clamp_end_time(recent_date, cutoff_days)
        assert result == recent_date
        assert modified is False