Buckets:

download
raw
7.52 kB
"""
Tests for P8s Vector Search module.
"""
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from sqlmodel import Field
from p8s.ai.fields import VectorField
from p8s.ai.vector_search import (
VectorSearch,
VectorSearchError,
create_vector_search,
)
from p8s.db.base import Model
class TestVectorSearch:
"""Test VectorSearch class."""
def test_create_vector_search(self):
"""Test creating a VectorSearch instance."""
class TestModel(Model):
content: str = Field(default="")
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding")
assert search.model == TestModel
assert search.vector_field == "embedding"
assert search.metric == "cosine"
def test_create_with_custom_metric(self):
"""Test creating with custom metric."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="l2")
assert search.metric == "l2"
def test_invalid_vector_field(self):
"""Test error on invalid vector field."""
class TestModel(Model):
name: str = Field(default="")
with pytest.raises(VectorSearchError):
VectorSearch(TestModel, "nonexistent")
def test_distance_operators(self):
"""Test distance operator mapping."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
# Cosine
search = VectorSearch(TestModel, "embedding", metric="cosine")
assert search._get_distance_operator() == "<=>"
# L2
search = VectorSearch(TestModel, "embedding", metric="l2")
assert search._get_distance_operator() == "<->"
# Inner product
search = VectorSearch(TestModel, "embedding", metric="inner_product")
assert search._get_distance_operator() == "<#>"
def test_invalid_metric(self):
"""Test error on invalid metric."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="invalid")
with pytest.raises(VectorSearchError):
search._get_distance_operator()
class TestDistanceComputation:
"""Test distance computation methods."""
def test_cosine_distance(self):
"""Test cosine distance computation."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="cosine")
# Same vectors = 0 distance
a = [1.0, 0.0, 0.0]
b = [1.0, 0.0, 0.0]
assert search._compute_distance(a, b) == pytest.approx(0.0)
# Orthogonal vectors = 1 distance
a = [1.0, 0.0]
b = [0.0, 1.0]
assert search._compute_distance(a, b) == pytest.approx(1.0)
# Opposite vectors = 2 distance
a = [1.0, 0.0]
b = [-1.0, 0.0]
assert search._compute_distance(a, b) == pytest.approx(2.0)
def test_l2_distance(self):
"""Test Euclidean distance computation."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="l2")
# Same vectors = 0 distance
a = [1.0, 2.0, 3.0]
b = [1.0, 2.0, 3.0]
assert search._compute_distance(a, b) == pytest.approx(0.0)
# Simple case
a = [0.0, 0.0]
b = [3.0, 4.0]
assert search._compute_distance(a, b) == pytest.approx(5.0)
def test_inner_product_distance(self):
"""Test inner product distance computation."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="inner_product")
a = [1.0, 2.0]
b = [3.0, 4.0]
# Inner product = 1*3 + 2*4 = 11
# Negative = -11
assert search._compute_distance(a, b) == pytest.approx(-11.0)
def test_dimension_mismatch(self):
"""Test error on dimension mismatch."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding")
a = [1.0, 2.0]
b = [1.0, 2.0, 3.0]
with pytest.raises(VectorSearchError):
search._compute_distance(a, b)
class TestFactoryFunction:
"""Test factory function."""
def test_create_vector_search_factory(self):
"""Test create_vector_search factory."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = create_vector_search(TestModel, "embedding", "l2")
assert isinstance(search, VectorSearch)
assert search.metric == "l2"
class TestPythonFallback:
"""Test Python fallback search - direct computation tests."""
def test_distance_ranking(self):
"""Test that distances are computed correctly for ranking."""
class TestModel(Model):
name: str = Field(default="")
embedding: list[float] | None = VectorField(source_field="name")
search = VectorSearch(TestModel, "embedding", metric="cosine")
# Query embedding
query = [1.0, 0.0, 0.0]
# Item embeddings with known distances
item1 = [1.0, 0.0, 0.0] # Identical = 0
item2 = [0.9, 0.1, 0.0] # Very similar < 0.1
item3 = [0.0, 1.0, 0.0] # Orthogonal = 1.0
d1 = search._compute_distance(query, item1)
d2 = search._compute_distance(query, item2)
d3 = search._compute_distance(query, item3)
# Check ordering
assert d1 < d2 < d3
assert d1 == pytest.approx(0.0)
assert d3 == pytest.approx(1.0)
def test_sorting_logic(self):
"""Test that items are sorted correctly by distance."""
# Create scored items like _search_python would
scored_items = [
("item3", 1.0),
("item1", 0.0),
("item2", 0.05),
]
# Sort by distance (the logic from _search_python)
scored_items.sort(key=lambda x: x[1])
assert scored_items[0][0] == "item1" # Closest
assert scored_items[1][0] == "item2"
assert scored_items[2][0] == "item3" # Farthest
def test_threshold_filtering(self):
"""Test threshold filtering logic."""
class TestModel(Model):
embedding: list[float] | None = VectorField(source_field="content")
search = VectorSearch(TestModel, "embedding", metric="cosine")
query = [1.0, 0.0, 0.0]
# Simulate items with different distances
test_cases = [
([1.0, 0.0, 0.0], 0.0), # Should pass threshold 0.5
([0.9, 0.1, 0.0], 0.02), # Should pass threshold 0.5
([0.0, 1.0, 0.0], 1.0), # Should NOT pass threshold 0.5
]
threshold = 0.5
passed = []
for embedding, expected_dist in test_cases:
distance = search._compute_distance(query, embedding)
if distance < threshold:
passed.append((embedding, distance))
# Only 2 items should pass the threshold
assert len(passed) == 2

Xet Storage Details

Size:
7.52 kB
·
Xet hash:
ac35264feb16072d13a9c5adbad20ab52150faf11ff7723bfe358663fafce871

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.