544 lines
16 KiB
Python
544 lines
16 KiB
Python
import abc
|
|
import decimal
|
|
import datetime
|
|
from typing import Optional, List
|
|
from unittest import mock
|
|
|
|
import pytest
|
|
import redis
|
|
from pydantic import ValidationError
|
|
|
|
from redis_developer.model import (
|
|
EmbeddedJsonModel,
|
|
JsonModel,
|
|
Field,
|
|
)
|
|
from redis_developer.model.migrations.migrator import Migrator
|
|
from redis_developer.model.model import QueryNotSupportedError, NotFoundError, RedisModelError
|
|
|
|
r = redis.Redis()
|
|
today = datetime.date.today()
|
|
|
|
|
|
class BaseJsonModel(JsonModel, abc.ABC):
|
|
class Meta:
|
|
global_key_prefix = "redis-developer"
|
|
|
|
|
|
class Note(EmbeddedJsonModel):
|
|
# TODO: This was going to be a full-text search example, but
|
|
# we can't index embedded documents for full-text search in
|
|
# the preview release.
|
|
description: str = Field(index=True)
|
|
created_on: datetime.datetime
|
|
|
|
|
|
class Address(EmbeddedJsonModel):
|
|
address_line_1: str
|
|
address_line_2: Optional[str]
|
|
city: str = Field(index=True)
|
|
state: str
|
|
country: str
|
|
postal_code: str = Field(index=True)
|
|
note: Optional[Note]
|
|
|
|
|
|
class Item(EmbeddedJsonModel):
|
|
price: decimal.Decimal
|
|
name: str = Field(index=True)
|
|
|
|
|
|
class Order(EmbeddedJsonModel):
|
|
items: List[Item]
|
|
created_on: datetime.datetime
|
|
|
|
|
|
class Member(BaseJsonModel):
|
|
first_name: str = Field(index=True)
|
|
last_name: str = Field(index=True)
|
|
email: str = Field(index=True)
|
|
join_date: datetime.date
|
|
age: int = Field(index=True)
|
|
bio: Optional[str] = Field(index=True, full_text_search=True, default="")
|
|
|
|
# Creates an embedded model.
|
|
address: Address
|
|
|
|
# Creates an embedded list of models.
|
|
orders: Optional[List[Order]]
|
|
|
|
|
|
@pytest.fixture()
|
|
def address():
|
|
yield Address(
|
|
address_line_1="1 Main St.",
|
|
city="Portland",
|
|
state="OR",
|
|
country="USA",
|
|
postal_code=11111
|
|
)
|
|
|
|
|
|
@pytest.fixture()
|
|
def members(address):
|
|
member1 = Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
email="a@example.com",
|
|
age=38,
|
|
join_date=today,
|
|
address=address
|
|
)
|
|
|
|
member2 = Member(
|
|
first_name="Kim",
|
|
last_name="Brookins",
|
|
email="k@example.com",
|
|
age=34,
|
|
join_date=today,
|
|
address=address
|
|
)
|
|
|
|
member3 = Member(
|
|
first_name="Andrew",
|
|
last_name="Smith",
|
|
email="as@example.com",
|
|
age=100,
|
|
join_date=today,
|
|
address=address
|
|
)
|
|
|
|
member1.save()
|
|
member2.save()
|
|
member3.save()
|
|
|
|
yield member1, member2, member3
|
|
|
|
|
|
def test_validates_required_fields(address):
|
|
# Raises ValidationError address is required
|
|
with pytest.raises(ValidationError):
|
|
Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
zipcode="97086",
|
|
join_date=today,
|
|
)
|
|
|
|
|
|
def test_validates_field(address):
|
|
# Raises ValidationError: join_date is not a date
|
|
with pytest.raises(ValidationError):
|
|
Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
join_date="yesterday",
|
|
address=address
|
|
)
|
|
|
|
|
|
# Passes validation
|
|
def test_validation_passes(address):
|
|
member = Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
email="a@example.com",
|
|
join_date=today,
|
|
age=38,
|
|
address=address
|
|
)
|
|
assert member.first_name == "Andrew"
|
|
|
|
|
|
def test_saves_model_and_creates_pk(address):
|
|
member = Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
email="a@example.com",
|
|
join_date=today,
|
|
age=38,
|
|
address=address
|
|
)
|
|
# Save a model instance to Redis
|
|
member.save()
|
|
|
|
member2 = Member.get(member.pk)
|
|
assert member2 == member
|
|
assert member2.address == address
|
|
|
|
|
|
@pytest.mark.skip("Not implemented yet")
|
|
def test_saves_many(address):
|
|
members = [
|
|
Member(
|
|
first_name="Andrew",
|
|
last_name="Brookins",
|
|
email="a@example.com",
|
|
join_date=today,
|
|
address=address,
|
|
age=38
|
|
),
|
|
Member(
|
|
first_name="Kim",
|
|
last_name="Brookins",
|
|
email="k@example.com",
|
|
join_date=today,
|
|
address=address,
|
|
age=34
|
|
)
|
|
]
|
|
Member.add(members)
|
|
|
|
|
|
@pytest.mark.skip("Not ready yet")
|
|
def test_updates_a_model(members):
|
|
member1, member2, member3 = members
|
|
|
|
# Or, with an implicit save:
|
|
member1.update(last_name="Smith")
|
|
assert Member.find(Member.pk == member1.pk).first() == member1
|
|
|
|
# Or, affecting multiple model instances with an implicit save:
|
|
Member.find(Member.last_name == "Brookins").update(last_name="Smith")
|
|
results = Member.find(Member.last_name == "Smith")
|
|
assert results == members
|
|
|
|
# Or, updating a field in an embedded model:
|
|
member2.update(address__city="Happy Valley")
|
|
assert Member.find(Member.pk == member2.pk).first().address.city == "Happy Valley"
|
|
|
|
|
|
def test_paginate_query(members):
|
|
member1, member2, member3 = members
|
|
actual = Member.find().all(batch_size=1)
|
|
assert actual == [member1, member2, member3]
|
|
|
|
|
|
def test_access_result_by_index_cached(members):
|
|
member1, member2, member3 = members
|
|
query = Member.find().sort_by('age')
|
|
# Load the cache, throw away the result.
|
|
assert query._model_cache == []
|
|
query.execute()
|
|
assert query._model_cache == [member2, member1, member3]
|
|
|
|
# Access an item that should be in the cache.
|
|
with mock.patch.object(query.model, 'db') as mock_db:
|
|
assert query[0] == member2
|
|
assert not mock_db.called
|
|
|
|
|
|
def test_access_result_by_index_not_cached(members):
|
|
member1, member2, member3 = members
|
|
query = Member.find().sort_by('age')
|
|
|
|
# Assert that we don't have any models in the cache yet -- we
|
|
# haven't made any requests of Redis.
|
|
assert query._model_cache == []
|
|
assert query[0] == member2
|
|
assert query[1] == member1
|
|
assert query[2] == member3
|
|
|
|
|
|
def test_in_query(members):
|
|
member1, member2, member3 = members
|
|
actual = Member.find(Member.pk << [member1.pk, member2.pk, member3.pk]).all()
|
|
assert actual == [member1, member2, member3]
|
|
|
|
|
|
@pytest.mark.skip("Not implemented yet")
|
|
def test_update_query(members):
|
|
member1, member2, member3 = members
|
|
Member.find(Member.pk << [member1.pk, member2.pk, member3.pk]).update(
|
|
first_name="Bobby"
|
|
)
|
|
actual = Member.find(
|
|
Member.pk << [member1.pk, member2.pk, member3.pk]).sort_by('age').all()
|
|
assert actual == [member1, member2, member3]
|
|
assert all([m.name == "Bobby" for m in actual])
|
|
|
|
|
|
def test_exact_match_queries(members):
|
|
member1, member2, member3 = members
|
|
|
|
actual = Member.find(Member.last_name == "Brookins").all()
|
|
assert actual == [member1, member2]
|
|
|
|
actual = Member.find(
|
|
(Member.last_name == "Brookins") & ~(Member.first_name == "Andrew")).all()
|
|
assert actual == [member2]
|
|
|
|
actual = Member.find(~(Member.last_name == "Brookins")).all()
|
|
assert actual == [member3]
|
|
|
|
actual = Member.find(Member.last_name != "Brookins").all()
|
|
assert actual == [member3]
|
|
|
|
actual = Member.find(
|
|
(Member.last_name == "Brookins") & (Member.first_name == "Andrew")
|
|
| (Member.first_name == "Kim")
|
|
).all()
|
|
assert actual == [member1, member2]
|
|
|
|
actual = Member.find(Member.first_name == "Kim", Member.last_name == "Brookins").all()
|
|
assert actual == [member2]
|
|
|
|
actual = Member.find(Member.address.city == "Portland").all()
|
|
assert actual == [member1, member2, member3]
|
|
|
|
|
|
def test_recursive_query_expression_resolution(members):
|
|
member1, member2, member3 = members
|
|
|
|
actual = Member.find((Member.last_name == "Brookins") | (
|
|
Member.age == 100
|
|
) & (Member.last_name == "Smith")).all()
|
|
assert actual == [member1, member2, member3]
|
|
|
|
|
|
def test_recursive_query_field_resolution(members):
|
|
member1, _, _ = members
|
|
member1.address.note = Note(description="Weird house",
|
|
created_on=datetime.datetime.now())
|
|
member1.save()
|
|
actual = Member.find(Member.address.note.description == "Weird house").all()
|
|
assert actual == [member1]
|
|
|
|
member1.orders = [
|
|
Order(items=[Item(price=10.99, name="Ball")],
|
|
total=10.99,
|
|
created_on=datetime.datetime.now())
|
|
]
|
|
member1.save()
|
|
actual = Member.find(Member.orders.items.name == "Ball").all()
|
|
assert actual == [member1]
|
|
assert actual[0].orders[0].items[0].name == "Ball"
|
|
|
|
|
|
def test_full_text_search(members):
|
|
member1, member2, _ = members
|
|
member1.update(bio="Hates sunsets, likes beaches")
|
|
member2.update(bio="Hates beaches, likes forests")
|
|
|
|
actual = Member.find(Member.bio % "beaches").all()
|
|
assert actual == [member1, member2]
|
|
|
|
actual = Member.find(Member.bio % "forests").all()
|
|
assert actual == [member2]
|
|
|
|
|
|
def test_tag_queries_boolean_logic(members):
|
|
member1, member2, member3 = members
|
|
|
|
actual = Member.find(
|
|
(Member.first_name == "Andrew") &
|
|
(Member.last_name == "Brookins") | (Member.last_name == "Smith")).all()
|
|
assert actual == [member1, member3]
|
|
|
|
|
|
def test_tag_queries_punctuation(address):
|
|
member1 = Member(
|
|
first_name="Andrew, the Michael",
|
|
last_name="St. Brookins-on-Pier",
|
|
email="a|b@example.com", # NOTE: This string uses the TAG field separator.
|
|
age=38,
|
|
join_date=today,
|
|
address=address
|
|
)
|
|
member1.save()
|
|
|
|
member2 = Member(
|
|
first_name="Bob",
|
|
last_name="the Villain",
|
|
email="a|villain@example.com", # NOTE: This string uses the TAG field separator.
|
|
age=38,
|
|
join_date=today,
|
|
address=address
|
|
)
|
|
member2.save()
|
|
|
|
assert Member.find(Member.first_name == "Andrew, the Michael").first() == member1
|
|
assert Member.find(Member.last_name == "St. Brookins-on-Pier").first() == member1
|
|
|
|
# Notice that when we index and query multiple values that use the internal
|
|
# TAG separator for single-value exact-match fields, like an indexed string,
|
|
# the queries will succeed. We apply a workaround that queries for the union
|
|
# of the two values separated by the tag separator.
|
|
assert Member.find(Member.email == "a|b@example.com").all() == [member1]
|
|
assert Member.find(Member.email == "a|villain@example.com").all() == [member2]
|
|
|
|
|
|
def test_tag_queries_negation(members):
|
|
member1, member2, member3 = members
|
|
|
|
"""
|
|
┌first_name
|
|
NOT EQ┤
|
|
└Andrew
|
|
|
|
"""
|
|
query = Member.find(
|
|
~(Member.first_name == "Andrew")
|
|
)
|
|
assert query.all() == [member2]
|
|
|
|
"""
|
|
┌first_name
|
|
┌NOT EQ┤
|
|
| └Andrew
|
|
AND┤
|
|
| ┌last_name
|
|
└EQ┤
|
|
└Brookins
|
|
|
|
"""
|
|
query = Member.find(
|
|
~(Member.first_name == "Andrew") & (Member.last_name == "Brookins")
|
|
)
|
|
assert query.all() == [member2]
|
|
|
|
"""
|
|
┌first_name
|
|
┌NOT EQ┤
|
|
| └Andrew
|
|
AND┤
|
|
| ┌last_name
|
|
| ┌EQ┤
|
|
| | └Brookins
|
|
└OR┤
|
|
| ┌last_name
|
|
└EQ┤
|
|
└Smith
|
|
"""
|
|
query = Member.find(
|
|
~(Member.first_name == "Andrew") &
|
|
((Member.last_name == "Brookins") | (Member.last_name == "Smith")))
|
|
assert query.all() == [member2]
|
|
|
|
"""
|
|
┌first_name
|
|
┌NOT EQ┤
|
|
| └Andrew
|
|
┌AND┤
|
|
| | ┌last_name
|
|
| └EQ┤
|
|
| └Brookins
|
|
OR┤
|
|
| ┌last_name
|
|
└EQ┤
|
|
└Smith
|
|
"""
|
|
query = Member.find(
|
|
~(Member.first_name == "Andrew") &
|
|
(Member.last_name == "Brookins") | (Member.last_name == "Smith"))
|
|
assert query.all() == [member2, member3]
|
|
|
|
actual = Member.find(
|
|
(Member.first_name == "Andrew") & ~(Member.last_name == "Brookins")).all()
|
|
assert actual == [member3]
|
|
|
|
|
|
def test_numeric_queries(members):
|
|
member1, member2, member3 = members
|
|
|
|
actual = Member.find(Member.age == 34).all()
|
|
assert actual == [member2]
|
|
|
|
actual = Member.find(Member.age > 34).all()
|
|
assert actual == [member1, member3]
|
|
|
|
actual = Member.find(Member.age < 35).all()
|
|
assert actual == [member2]
|
|
|
|
actual = Member.find(Member.age <= 34).all()
|
|
assert actual == [member2]
|
|
|
|
actual = Member.find(Member.age >= 100).all()
|
|
assert actual == [member3]
|
|
|
|
actual = Member.find(~(Member.age == 100)).all()
|
|
assert actual == [member1, member2]
|
|
|
|
actual = Member.find(Member.age > 30, Member.age < 40).all()
|
|
assert actual == [member1, member2]
|
|
|
|
actual = Member.find(Member.age != 34).all()
|
|
assert actual == [member1, member3]
|
|
|
|
|
|
def test_sorting(members):
|
|
member1, member2, member3 = members
|
|
|
|
actual = Member.find(Member.age > 34).sort_by('age').all()
|
|
assert actual == [member1, member3]
|
|
|
|
actual = Member.find(Member.age > 34).sort_by('-age').all()
|
|
assert actual == [member3, member1]
|
|
|
|
with pytest.raises(QueryNotSupportedError):
|
|
# This field does not exist.
|
|
Member.find().sort_by('not-a-real-field').all()
|
|
|
|
with pytest.raises(QueryNotSupportedError):
|
|
# This field is not sortable.
|
|
Member.find().sort_by('join_date').all()
|
|
|
|
|
|
def test_not_found():
|
|
with pytest.raises(NotFoundError):
|
|
# This ID does not exist.
|
|
Member.get(1000)
|
|
|
|
|
|
def test_list_field_limitations():
|
|
with pytest.raises(RedisModelError):
|
|
class SortableTarotWitch(BaseJsonModel):
|
|
# We support indexing lists of strings for quality and membership
|
|
# queries. Sorting is not supported, but is planned.
|
|
tarot_cards: List[str] = Field(index=True, sortable=True)
|
|
|
|
with pytest.raises(RedisModelError):
|
|
class SortableFullTextSearchAlchemicalWitch(BaseJsonModel):
|
|
# We don't support indexing a list of strings for full-text search
|
|
# queries. Support for this feature is not planned.
|
|
potions: List[str] = Field(index=True, full_text_search=True)
|
|
|
|
with pytest.raises(RedisModelError):
|
|
class NumerologyWitch(BaseJsonModel):
|
|
# We don't support indexing a list of numbers. Support for this
|
|
# feature is To Be Determined.
|
|
lucky_numbers: List[int] = Field(index=True)
|
|
|
|
with pytest.raises(RedisModelError):
|
|
class ReadingWithPrice(EmbeddedJsonModel):
|
|
gold_coins_charged: int = Field(index=True)
|
|
|
|
class TarotWitchWhoCharges(BaseJsonModel):
|
|
tarot_cards: List[str] = Field(index=True)
|
|
|
|
# The preview release does not support indexing numeric fields on models
|
|
# found within a list or tuple. This is the same limitation that stops
|
|
# us from indexing plain lists (or tuples) containing numeric values.
|
|
# The fate of this feature is To Be Determined.
|
|
readings: List[ReadingWithPrice]
|
|
|
|
class TarotWitch(BaseJsonModel):
|
|
# We support indexing lists of strings for quality and membership
|
|
# queries. Sorting is not supported, but is planned.
|
|
tarot_cards: List[str] = Field(index=True)
|
|
|
|
# We need to import and run this manually because we defined
|
|
# our model classes within a function that runs after the test
|
|
# suite's migrator has already looked for migrations to run.
|
|
Migrator().run()
|
|
|
|
witch = TarotWitch(
|
|
tarot_cards=['death']
|
|
)
|
|
witch.save()
|
|
actual = TarotWitch.find(TarotWitch.tarot_cards << 'death').all()
|
|
assert actual == [witch]
|
|
|
|
|
|
def test_schema():
|
|
assert Member.redisearch_schema() == "ON JSON PREFIX 1 redis-developer:tests.test_json_model.Member: SCHEMA $.pk AS pk TAG SEPARATOR | $.first_name AS first_name TAG SEPARATOR | $.last_name AS last_name TAG SEPARATOR | $.email AS email TAG SEPARATOR | $.age AS age NUMERIC $.bio AS bio TAG SEPARATOR | $.bio AS bio_fts TEXT $.address.pk AS address_pk TAG SEPARATOR | $.address.city AS address_city TAG SEPARATOR | $.address.postal_code AS address_postal_code TAG SEPARATOR | $.address.note.pk AS address_note_pk TAG SEPARATOR | $.address.note.description AS address_note_description TAG SEPARATOR | $.orders[*].pk AS orders_pk TAG SEPARATOR | $.orders[*].items[*].pk AS orders_items_pk TAG SEPARATOR | $.orders[*].items[*].name AS orders_items_name TAG SEPARATOR |" |