path: root/src/mango/test/06-basic-text-test.py

# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.

import json
import mango
import unittest
import user_docs
import math
from hypothesis import given, assume, example
import hypothesis.strategies as st


@unittest.skipIf(mango.has_text_service(), "text service exists")
class TextIndexCheckTests(mango.DbPerClass):
    def test_create_text_index(self):
        body = json.dumps({"index": {}, "type": "text"})
        resp = self.db.sess.post(self.db.path("_index"), data=body)
        assert resp.status_code == 503, resp


@unittest.skipUnless(mango.has_text_service(), "requires text service")
class BasicTextTests(mango.UserDocsTextTests):
    def test_simple(self):
        docs = self.db.find({"$text": "Stephanie"})
        assert len(docs) == 1
        assert docs[0]["name"]["first"] == "Stephanie"

    def test_with_integer(self):
        docs = self.db.find({"name.first": "Stephanie", "age": 48})
        assert len(docs) == 1
        assert docs[0]["name"]["first"] == "Stephanie"
        assert docs[0]["age"] == 48

    def test_with_boolean(self):
        docs = self.db.find({"name.first": "Stephanie", "manager": False})
        assert len(docs) == 1
        assert docs[0]["name"]["first"] == "Stephanie"
        assert docs[0]["manager"] == False

    def test_with_array(self):
        faves = ["Ruby", "C", "Python"]
        docs = self.db.find({"name.first": "Stephanie", "favorites": faves})
        assert docs[0]["name"]["first"] == "Stephanie"
        assert docs[0]["favorites"] == faves

    def test_array_ref(self):
        docs = self.db.find({"favorites.1": "Python"})
        assert len(docs) == 4
        for d in docs:
            assert "Python" in d["favorites"]

        # Nested Level
        docs = self.db.find({"favorites.0.2": "Python"})
        assert len(docs) == 1
        for d in docs:
            assert "Python" in d["favorites"][0][2]

    def test_number_ref(self):
        docs = self.db.find({"11111": "number_field"})
        assert len(docs) == 1
        assert docs[0]["11111"] == "number_field"

        docs = self.db.find({"22222.33333": "nested_number_field"})
        assert len(docs) == 1
        assert docs[0]["22222"]["33333"] == "nested_number_field"

    def test_lt(self):
        docs = self.db.find({"age": {"$lt": 22}})
        assert len(docs) == 0

        docs = self.db.find({"age": {"$lt": 23}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": {"$lt": 33}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (1, 9)

        docs = self.db.find({"age": {"$lt": 34}})
        assert len(docs) == 3
        for d in docs:
            assert d["user_id"] in (1, 7, 9)

        docs = self.db.find({"company": {"$lt": "Dreamia"}})
        assert len(docs) == 1
        assert docs[0]["company"] == "Affluex"

        docs = self.db.find({"foo": {"$lt": "bar car apple"}})
        assert len(docs) == 0

    def test_lte(self):
        docs = self.db.find({"age": {"$lte": 21}})
        assert len(docs) == 0

        docs = self.db.find({"age": {"$lte": 22}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": {"$lte": 33}})
        assert len(docs) == 3
        for d in docs:
            assert d["user_id"] in (1, 7, 9)

        docs = self.db.find({"company": {"$lte": "Dreamia"}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (0, 11)

        docs = self.db.find({"foo": {"$lte": "bar car apple"}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 14

    def test_eq(self):
        docs = self.db.find({"age": 21})
        assert len(docs) == 0

        docs = self.db.find({"age": 22})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": {"$eq": 22}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": 33})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 7

    def test_ne(self):
        docs = self.db.find({"age": {"$ne": 22}})
        assert len(docs) == len(user_docs.DOCS) - 1
        for d in docs:
            assert d["age"] != 22

        docs = self.db.find({"$not": {"age": 22}})
        assert len(docs) == len(user_docs.DOCS) - 1
        for d in docs:
            assert d["age"] != 22

    def test_gt(self):
        docs = self.db.find({"age": {"$gt": 77}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (3, 13)

        docs = self.db.find({"age": {"$gt": 78}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 3

        docs = self.db.find({"age": {"$gt": 79}})
        assert len(docs) == 0

        docs = self.db.find({"company": {"$gt": "Zialactic"}})
        assert len(docs) == 0

        docs = self.db.find({"foo": {"$gt": "bar car apple"}})
        assert len(docs) == 0

        docs = self.db.find({"foo": {"$gt": "bar car"}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 14

    def test_gte(self):
        docs = self.db.find({"age": {"$gte": 77}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (3, 13)

        docs = self.db.find({"age": {"$gte": 78}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (3, 13)

        docs = self.db.find({"age": {"$gte": 79}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 3

        docs = self.db.find({"age": {"$gte": 80}})
        assert len(docs) == 0

        docs = self.db.find({"company": {"$gte": "Zialactic"}})
        assert len(docs) == 1
        assert docs[0]["company"] == "Zialactic"

        docs = self.db.find({"foo": {"$gte": "bar car apple"}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 14

    def test_and(self):
        docs = self.db.find({"age": 22, "manager": True})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": 22, "manager": False})
        assert len(docs) == 0

        docs = self.db.find({"$and": [{"age": 22}, {"manager": True}]})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"$and": [{"age": 22}, {"manager": False}]})
        assert len(docs) == 0

        docs = self.db.find({"$text": "Ramona", "age": 22})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"$and": [{"$text": "Ramona"}, {"age": 22}]})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"$and": [{"$text": "Ramona"}, {"$text": "Floyd"}]})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

    def test_or(self):
        docs = self.db.find({"$or": [{"age": 22}, {"age": 33}]})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (7, 9)

        q = {"$or": [{"$text": "Ramona"}, {"$text": "Stephanie"}]}
        docs = self.db.find(q)
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (0, 9)

        q = {"$or": [{"$text": "Ramona"}, {"age": 22}]}
        docs = self.db.find(q)
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

    def test_and_or(self):
        q = {"age": 22, "$or": [{"manager": False}, {"location.state": "Missouri"}]}
        docs = self.db.find(q)
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        q = {"$or": [{"age": 22}, {"age": 43, "manager": True}]}
        docs = self.db.find(q)
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (9, 10)

        q = {"$or": [{"$text": "Ramona"}, {"age": 43, "manager": True}]}
        docs = self.db.find(q)
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (9, 10)

    def test_nor(self):
        docs = self.db.find({"$nor": [{"age": 22}, {"age": 33}]})
        assert len(docs) == 13
        for d in docs:
            assert d["user_id"] not in (7, 9)

    def test_in_with_value(self):
        docs = self.db.find({"age": {"$in": [1, 5]}})
        assert len(docs) == 0

        docs = self.db.find({"age": {"$in": [1, 5, 22]}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 9

        docs = self.db.find({"age": {"$in": [1, 5, 22, 31]}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (1, 9)

        docs = self.db.find({"age": {"$in": [22, 31]}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (1, 9)

        # Limits on boolean clauses?
        docs = self.db.find({"age": {"$in": list(range(1000))}})
        assert len(docs) == 15

    def test_in_with_array(self):
        vals = ["Random Garbage", 52, {"Versions": {"Alpha": "Beta"}}]
        docs = self.db.find({"favorites": {"$in": vals}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 1

        vals = ["Lisp", "Python"]
        docs = self.db.find({"favorites": {"$in": vals}})
        assert len(docs) == 10

        vals = [{"val1": 1, "val2": "val2"}]
        docs = self.db.find({"test_in": {"$in": vals}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 2

    def test_nin_with_value(self):
        docs = self.db.find({"age": {"$nin": [1, 5]}})
        assert len(docs) == len(user_docs.DOCS)

        docs = self.db.find({"age": {"$nin": [1, 5, 22]}})
        assert len(docs) == len(user_docs.DOCS) - 1
        for d in docs:
            assert d["user_id"] != 9

        docs = self.db.find({"age": {"$nin": [1, 5, 22, 31]}})
        assert len(docs) == len(user_docs.DOCS) - 2
        for d in docs:
            assert d["user_id"] not in (1, 9)

        docs = self.db.find({"age": {"$nin": [22, 31]}})
        assert len(docs) == len(user_docs.DOCS) - 2
        for d in docs:
            assert d["user_id"] not in (1, 9)

        # Limits on boolean clauses?
        docs = self.db.find({"age": {"$nin": list(range(1000))}})
        assert len(docs) == 0

    def test_nin_with_array(self):
        vals = ["Random Garbage", 52, {"Versions": {"Alpha": "Beta"}}]
        docs = self.db.find({"favorites": {"$nin": vals}})
        assert len(docs) == len(user_docs.DOCS) - 1
        for d in docs:
            assert d["user_id"] != 1

        vals = ["Lisp", "Python"]
        docs = self.db.find({"favorites": {"$nin": vals}})
        assert len(docs) == 5

        vals = [{"val1": 1, "val2": "val2"}]
        docs = self.db.find({"test_in": {"$nin": vals}})
        assert len(docs) == 0

    def test_all(self):
        vals = ["Ruby", "C", "Python", {"Versions": {"Alpha": "Beta"}}]
        docs = self.db.find({"favorites": {"$all": vals}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 1

        # This matches where favorites either contains
        # the nested array, or is the nested array. This is
        # notably different than the non-nested array in that
        # it does not match a re-ordered version of the array.
        # The fact that user_id 14 isn't included demonstrates
        # this behavior.
        vals = [["Lisp", "Erlang", "Python"]]
        docs = self.db.find({"favorites": {"$all": vals}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (3, 9)

    def test_exists_field(self):
        docs = self.db.find({"exists_field": {"$exists": True}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (7, 8)

        docs = self.db.find({"exists_field": {"$exists": False}})
        assert len(docs) == len(user_docs.DOCS) - 2
        for d in docs:
            assert d["user_id"] not in (7, 8)

    def test_exists_array(self):
        docs = self.db.find({"exists_array": {"$exists": True}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (9, 10)

        docs = self.db.find({"exists_array": {"$exists": False}})
        assert len(docs) == len(user_docs.DOCS) - 2
        for d in docs:
            assert d["user_id"] not in (9, 10)

    def test_exists_object(self):
        docs = self.db.find({"exists_object": {"$exists": True}})
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (11, 12)

        docs = self.db.find({"exists_object": {"$exists": False}})
        assert len(docs) == len(user_docs.DOCS) - 2
        for d in docs:
            assert d["user_id"] not in (11, 12)

    def test_exists_object_member(self):
        docs = self.db.find({"exists_object.should": {"$exists": True}})
        assert len(docs) == 1
        assert docs[0]["user_id"] == 11

        docs = self.db.find({"exists_object.should": {"$exists": False}})
        assert len(docs) == len(user_docs.DOCS) - 1
        for d in docs:
            assert d["user_id"] != 11

    def test_exists_and(self):
        q = {
            "$and": [
                {"manager": {"$exists": True}},
                {"exists_object.should": {"$exists": True}},
            ]
        }
        docs = self.db.find(q)
        assert len(docs) == 1
        assert docs[0]["user_id"] == 11

        q = {
            "$and": [
                {"manager": {"$exists": False}},
                {"exists_object.should": {"$exists": True}},
            ]
        }
        docs = self.db.find(q)
        assert len(docs) == 0

        # Translates to manager exists or exists_object.should doesn't
        # exist, which will match all docs
        q = {"$not": q}
        docs = self.db.find(q)
        assert len(docs) == len(user_docs.DOCS)

    def test_value_chars(self):
        q = {"complex_field_value": '+-(){}[]^~&&*||"\\/?:!'}
        docs = self.db.find(q)
        assert len(docs) == 1

    def test_regex(self):
        docs = self.db.find(
            {"age": {"$gt": 40}, "location.state": {"$regex": "(?i)new.*"}}
        )
        assert len(docs) == 2
        assert docs[0]["user_id"] == 2
        assert docs[1]["user_id"] == 10

    # test lucene syntax in $text


@unittest.skipUnless(mango.has_text_service(), "requires text service")
class ElemMatchTests(mango.FriendDocsTextTests):
    def test_elem_match_non_object(self):
        q = {"bestfriends": {"$elemMatch": {"$eq": "Wolverine", "$eq": "Cyclops"}}}
        docs = self.db.find(q)
        self.assertEqual(len(docs), 1)
        self.assertEqual(docs[0]["bestfriends"], ["Wolverine", "Cyclops"])

        q = {"results": {"$elemMatch": {"$gte": 80, "$lt": 85}}}

        docs = self.db.find(q)
        self.assertEqual(len(docs), 1)
        self.assertEqual(docs[0]["results"], [82, 85, 88])

    def test_elem_match(self):
        q = {"friends": {"$elemMatch": {"name.first": "Vargas"}}}
        docs = self.db.find(q)
        self.assertEqual(len(docs), 2)
        for d in docs:
            self.assertIn(d["user_id"], (0, 1))

        q = {"friends": {"$elemMatch": {"name.first": "Ochoa", "name.last": "Burch"}}}
        docs = self.db.find(q)
        self.assertEqual(len(docs), 1)
        self.assertEqual(docs[0]["user_id"], 4)

        # Check that we can do logic in elemMatch
        q = {"friends": {"$elemMatch": {"name.first": "Ochoa", "type": "work"}}}
        docs = self.db.find(q)
        self.assertEqual(len(docs), 2)
        for d in docs:
            self.assertIn(d["user_id"], (1, 15))

        q = {
            "friends": {
                "$elemMatch": {
                    "name.first": "Ochoa",
                    "$or": [{"type": "work"}, {"type": "personal"}],
                }
            }
        }
        docs = self.db.find(q)
        self.assertEqual(len(docs), 3)
        for d in docs:
            self.assertIn(d["user_id"], (1, 4, 15))

        # Same as last, but using $in
        q = {
            "friends": {
                "$elemMatch": {
                    "name.first": "Ochoa",
                    "type": {"$in": ["work", "personal"]},
                }
            }
        }
        docs = self.db.find(q)
        self.assertEqual(len(docs), 3)
        for d in docs:
            self.assertIn(d["user_id"], (1, 4, 15))

        q = {
            "$and": [
                {"friends": {"$elemMatch": {"id": 0, "name": {"$exists": True}}}},
                {
                    "friends": {
                        "$elemMatch": {
                            "$or": [
                                {"name": {"first": "Campos", "last": "Freeman"}},
                                {
                                    "name": {
                                        "$in": [
                                            {"first": "Gibbs", "last": "Mccarty"},
                                            {"first": "Wilkins", "last": "Chang"},
                                        ]
                                    }
                                },
                            ]
                        }
                    }
                },
            ]
        }
        docs = self.db.find(q)
        self.assertEqual(len(docs), 3)
        for d in docs:
            self.assertIn(d["user_id"], (10, 11, 12))


@unittest.skipUnless(mango.has_text_service(), "requires text service")
class AllMatchTests(mango.FriendDocsTextTests):
    def test_all_match(self):
        q = {"friends": {"$allMatch": {"type": "personal"}}}
        docs = self.db.find(q)
        assert len(docs) == 2
        for d in docs:
            assert d["user_id"] in (8, 5)

        # Check that we can do logic in allMatch
        q = {
            "friends": {
                "$allMatch": {
                    "name.first": "Ochoa",
                    "$or": [{"type": "work"}, {"type": "personal"}],
                }
            }
        }
        docs = self.db.find(q)
        assert len(docs) == 1
        assert docs[0]["user_id"] == 15

        # Same as last, but using $in
        q = {
            "friends": {
                "$allMatch": {
                    "name.first": "Ochoa",
                    "type": {"$in": ["work", "personal"]},
                }
            }
        }
        docs = self.db.find(q)
        assert len(docs) == 1
        assert docs[0]["user_id"] == 15


# Test numeric strings for $text
@unittest.skipUnless(mango.has_text_service(), "requires text service")
class NumStringTests(mango.DbPerClass):
    @classmethod
    def setUpClass(klass):
        super(NumStringTests, klass).setUpClass()
        klass.db.recreate()
        if mango.has_text_service():
            klass.db.create_text_index()

    # not available for python 2.7.x
    def isFinite(num):
        not (math.isinf(num) or math.isnan(num))

    @given(f=st.floats().filter(isFinite).map(str) | st.floats().map(lambda f: f.hex()))
    @example("NaN")
    @example("Infinity")
    def test_floating_point_val(self, f):
        doc = {"number_string": f}
        self.db.save_doc(doc)
        q = {"$text": f}
        docs = self.db.find(q)
        if len(docs) == 1:
            assert docs[0]["number_string"] == f
        if len(docs) == 2:
            if docs[0]["number_string"] != f:
                assert docs[1]["number_string"] == f
        q = {"number_string": f}
        docs = self.db.find(q)
        if len(docs) == 1:
            assert docs[0]["number_string"] == f
        if len(docs) == 2:
            if docs[0]["number_string"] != f:
                assert docs[1]["number_string"] == f