Skip to content

BrainAPI is a knowledge graph–powered AI memory layer that transforms unstructured data into structured knowledge, enabling intelligent search, recommendations, and contextual memory for AI agents and applications.

6.0 KB
Raw Blame
import os
import sys
import unittest
from datetime import datetime, timedelta, timezone

ENV_DEFAULTS = {
    "BRAINPAT_TOKEN": "test-token",
    "MODELS_MODE": "local",
    "EMBEDDINGS_LOCAL_MODEL": "local-model",
    "EMBEDDINGS_SMALL_MODEL": "small-model",
    "EMBEDDING_NODES_DIMENSION": "3",
    "EMBEDDING_TRIPLETS_DIMENSION": "3",
    "EMBEDDING_OBSERVATIONS_DIMENSION": "3",
    "EMBEDDING_DATA_DIMENSION": "3",
    "EMBEDDING_RELATIONSHIPS_DIMENSION": "3",
    "REDIS_HOST": "localhost",
    "REDIS_PORT": "6379",
    "NEO4J_HOST": "localhost",
    "NEO4J_PORT": "7687",
    "NEO4J_USERNAME": "neo4j",
    "NEO4J_PASSWORD": "password",
    "MILVUS_HOST": "localhost",
    "MILVUS_PORT": "19530",
    "MONGO_CONNECTION_STRING": "mongodb://localhost:27017",
    "CELERY_WORKER_CONCURRENCY": "1",
    "OLLAMA_HOST": "localhost",
    "OLLAMA_PORT": "11434",
    "OLLAMA_LLM_SMALL_MODEL": "small",
    "OLLAMA_LLM_LARGE_MODEL": "large",
    "POSTGRES_HOST": "localhost",
    "POSTGRES_PORT": "5432",
    "POSTGRES_USERNAME": "postgres",
    "POSTGRES_PASSWORD": "postgres",
}
for key, value in ENV_DEFAULTS.items():
    os.environ.setdefault(key, value)

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.utils.dates import (
    normalize_date_string,
    parse_date_string,
    resolve_relative_date,
    to_naive_utc,
)

LOCOMO_TIMESTAMP = "1:56 pm on 8 May, 2023"


class ParseDateStringTests(unittest.TestCase):
    def test_locomo_session_timestamp_parses(self):
        self.assertEqual(
            parse_date_string(LOCOMO_TIMESTAMP),
            datetime(2023, 5, 8, 13, 56),
        )

    def test_locomo_morning_timestamp_parses(self):
        self.assertEqual(
            parse_date_string("10:37 am on 27 June, 2023"),
            datetime(2023, 6, 27, 10, 37),
        )

    def test_iso_variants_parse(self):
        expected = datetime(2023, 5, 8, 13, 56)
        for value in (
            "2023-05-08T13:56:00",
            "2023-05-08T13:56:00.000000",
            "2023-05-08T13:56:00Z",
            "2023-05-08T13:56:00+00:00",
            "2023-05-08 13:56:00",
            "2023-05-08 13:56:00.000000",
            "2023-05-08 13:56:00+00:00",
        ):
            with self.subTest(value=value):
                self.assertEqual(parse_date_string(value), expected)

    def test_offset_aware_input_is_converted_to_naive_utc(self):
        parsed = parse_date_string("2023-05-08T13:56:00+02:00")
        self.assertEqual(parsed, datetime(2023, 5, 8, 11, 56))
        self.assertIsNone(parsed.tzinfo)

    def test_parsed_value_never_breaks_subtraction(self):
        parsed = parse_date_string("2023-05-08T13:56:00-05:00")
        self.assertIsInstance(datetime.now() - parsed, timedelta)

    def test_ambiguous_numeric_date_is_day_first(self):
        self.assertEqual(parse_date_string("08/05/2023"), datetime(2023, 5, 8))
        self.assertEqual(normalize_date_string("08/05/2023"), "08/05/2023")

    def test_day_first_holds_for_unambiguous_high_day(self):
        self.assertEqual(parse_date_string("25/05/2023"), datetime(2023, 5, 25))

    def test_unparseable_value_returns_none(self):
        self.assertIsNone(parse_date_string("sometime last summer"))

    def test_previously_supported_formats_still_parse(self):
        expected = datetime(2023, 5, 8)
        for value in ("08/05/2023", "2023-05-08", "2023/05/08", "08-05-2023",
                      "May 8, 2023", "May 8 2023", "8 May 2023"):
            with self.subTest(value=value):
                self.assertEqual(parse_date_string(value), expected)


class NormalizeDateStringTests(unittest.TestCase):
    def test_output_format_is_day_first_slashed(self):
        self.assertEqual(normalize_date_string(LOCOMO_TIMESTAMP), "08/05/2023")
        self.assertEqual(normalize_date_string("2023-05-08T13:56:00Z"), "08/05/2023")
        self.assertEqual(normalize_date_string("2023-05-08"), "08/05/2023")

    def test_unparseable_value_passes_through_stripped(self):
        self.assertEqual(
            normalize_date_string("  sometime last summer  "),
            "sometime last summer",
        )


class ResolveRelativeDateTests(unittest.TestCase):
    def test_yesterday_against_locomo_timestamp(self):
        self.assertEqual(
            resolve_relative_date("yesterday", LOCOMO_TIMESTAMP),
            "07/05/2023",
        )

    def test_last_tuesday_against_locomo_timestamp(self):
        self.assertEqual(
            resolve_relative_date("last Tuesday", LOCOMO_TIMESTAMP),
            "02/05/2023",
        )

    def test_days_ago_against_locomo_timestamp(self):
        self.assertEqual(
            resolve_relative_date("3 days ago", LOCOMO_TIMESTAMP),
            "05/05/2023",
        )

    def test_weeks_ago_against_locomo_timestamp(self):
        self.assertEqual(
            resolve_relative_date("2 weeks ago", LOCOMO_TIMESTAMP),
            "24/04/2023",
        )

    def test_unparseable_expression_returns_input_unchanged(self):
        self.assertEqual(
            resolve_relative_date("a few months ago", LOCOMO_TIMESTAMP),
            "a few months ago",
        )

    def test_unparseable_reference_returns_input_unchanged(self):
        self.assertEqual(
            resolve_relative_date("yesterday", "whenever it was"),
            "yesterday",
        )

    def test_next_month_on_century_non_leap_year_does_not_crash(self):
        self.assertEqual(
            resolve_relative_date("next month", "2100-01-31"),
            "28/02/2100",
        )

    def test_last_month_on_century_non_leap_year_does_not_crash(self):
        self.assertEqual(
            resolve_relative_date("last month", "2100-03-31"),
            "28/02/2100",
        )


class ToNaiveUtcTests(unittest.TestCase):
    def test_naive_value_is_returned_unchanged(self):
        value = datetime(2023, 5, 8, 13, 56)
        self.assertIs(to_naive_utc(value), value)

    def test_aware_value_is_shifted_to_utc(self):
        value = datetime(2023, 5, 8, 13, 56, tzinfo=timezone(timedelta(hours=2)))
        self.assertEqual(to_naive_utc(value), datetime(2023, 5, 8, 11, 56))


if __name__ == "__main__":
    unittest.main()