Skip to content
Snippets Groups Projects
Select Git revision
  • 64310b9d300858169307d98c0bb18a6c1dd3d598
  • main default protected
  • dev protected
  • f-fix-accent-sensitivity
  • f-filesystem-import
  • f-update-acl
  • f-filesystem-link
  • f-filesystem-directory
  • f-filesystem-core
  • f-filesystem-cleanup
  • f-string-ids
  • f-filesystem-main
  • f-multipart-encoding
  • f-trigger-advanced-user-tools
  • f-real-rename-test-pylibsolo2
  • f-real-rename-test-pylibsolo
  • f-real-rename-test
  • f-linkahead-rename
  • f-reference-record
  • f-xml-serialization
  • f-xfail-server-181
  • linkahead-pylib-v0.18.0
  • linkahead-control-v0.16.0
  • linkahead-pylib-v0.17.0
  • linkahead-mariadbbackend-v8.0.0
  • linkahead-server-v0.13.0
  • caosdb-pylib-v0.15.0
  • caosdb-pylib-v0.14.0
  • caosdb-pylib-v0.13.2
  • caosdb-server-v0.12.1
  • caosdb-pylib-v0.13.1
  • caosdb-pylib-v0.12.0
  • caosdb-server-v0.10.0
  • caosdb-pylib-v0.11.1
  • caosdb-pylib-v0.11.0
  • caosdb-server-v0.9.0
  • caosdb-pylib-v0.10.0
  • caosdb-server-v0.8.1
  • caosdb-pylib-v0.8.0
  • caosdb-server-v0.8.0
  • caosdb-pylib-v0.7.2
41 results

test_issues_server.py

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    test_query.py 43.27 KiB
    # encoding: utf-8
    #
    # ** header v3.0
    # This file is a part of the CaosDB Project.
    #
    # Copyright (C) 2018 Research Group Biomedical Physics,
    # Max-Planck-Institute for Dynamics and Self-Organization Göttingen
    #
    # This program is free software: you can redistribute it and/or modify
    # it under the terms of the GNU Affero General Public License as
    # published by the Free Software Foundation, either version 3 of the
    # License, or (at your option) any later version.
    #
    # This program is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # GNU Affero General Public License for more details.
    #
    # You should have received a copy of the GNU Affero General Public License
    # along with this program. If not, see <https://www.gnu.org/licenses/>.
    #
    # ** end header
    #
    """Created on 26.01.2015.
    
    @author: tf
    """
    
    
    import os
    import random
    import caosdb as db
    
    from pytest import mark, raises
    from caosdb.connection.connection import get_connection
    from caosdb.exceptions import EmptyUniqueQueryError
    from lxml import etree
    
    
    def setup_module():
        db.administration.set_server_property("AUTH_OPTIONAL", "TRUE")
        perms = db.administration._get_permissions("anonymous")
        assert perms == set()
    
    
    def setup_function(function):
        try:
            db.execute_query("FIND *").delete()
        except Exception as e:
            print(e)
    
    
    def teardown_function(function):
        db.configure_connection()
        setup_function(function)
        try:
            os.remove("test.dat")
        except Exception as e:
            print(e)
    
    
    def test_query_with_reference_by_parent():
        db.RecordType("TestExperiment").insert()
        db.RecordType("TestProtocolLog").insert()
        db.RecordType("TestSpecialProtocolLog").add_parent(
            name="TestProtocolLog").insert()
    
        sp_rec = db.Record("TestSpecialProtocolLog1").add_parent(
            name="TestSpecialProtocolLog").insert()
        exp_rec = db.Record("TestExperiment1").add_parent(
            name="TestExperiment").add_property(
            name="TestProtocolLog",
            datatype=db.LIST("TestProtocolLog"),
            value=[
                sp_rec.id]).insert()
        assert 2 == len(db.execute_query("FIND TestExperiment"))
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment WHICH HAS A TestProtocolLog", unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment.TestProtocolLog", unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment WHICH REFERENCES " + str(sp_rec.id), unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment WHICH REFERENCES TestSpecialProtocolLog1",
            unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment WHICH REFERENCES TestSpecialProtocolLog",
            unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment .-> " + str(sp_rec.id), unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment .-> TestSpecialProtocolLog1", unique=True).id
        assert exp_rec.id == db.execute_query(
            "FIND TestExperiment .-> TestSpecialProtocolLog", unique=True).id
    
        assert 0 == len(db.execute_query(
            "FIND TestExperiment WHICH HAS A TestProtocolLog1"))
        assert 0 == len(db.execute_query("FIND TestExperiment.TestProtocolLog1"))
    
    
    def test_query_with_domains():
        person = db.RecordType("TestPerson").insert()
        db.Property("TestFirstName", datatype=db.TEXT).insert()
        db.Property("TestConductor", datatype=db.REFERENCE).insert()
    
        # TODO: new test for TestFirstName with overridden datatype=person
        dan = db.Record(
            name="TestDaniel").add_property(
            name="TestFirstName",
            value="Daniel").add_parent(person).insert()
        exp = db.RecordType(
            name="TestExperiment").add_property(
            name="TestConductor",
            datatype=person,
            value=dan.id).insert()
    
        assert db.execute_query(
            "FIND TestExperiment WHICH HAS A TestConductor->TestPerson",
            unique=True).id == exp.id
        assert db.execute_query(
            "FIND TestExperiment WHICH HAS A TestConductor=TestPerson",
            unique=True).id == exp.id
        assert db.execute_query(
            "FIND TestExperiment WHICH HAS A TestConductor=" + str(dan.id), unique=True).id == exp.id
        assert db.execute_query("FIND TestExperiment", unique=True).id == exp.id
        assert db.execute_query(
            "FIND TestExperiment WHICH HAS A TestConductor WHICH has a TestFirstName=Daniel",
            unique=True).id == exp.id
    
    
    def test_query1():
        p = (
            db.Property(
                name="TestTextProperty",
                description="Test text property (from test_tenpoints.py)",
                datatype='text'))
        p.insert()
    
        assert int(p.id) >= 100
        assert p.id == db.execute_query("FIND TestTextProperty")[0].id
        assert p.id == db.execute_query("FIND TestTextProperty", unique=True).id
    
    
    def test_query2():
        # create testfile
        f = open("test.dat", "w")
        f.write("hello world\n")
        f.close()
    
        ''' prepare file record '''
        f = db.File(name="TestFile", path='testfiles/testfile', file="test.dat")
        f.insert()
    
        f2 = db.File(name="TestFile2", path='testfiles/testfile2', file="test.dat")
        f2.insert()
    
        assert int(f.id) >= 100
        assert 2 == len(db.execute_query("FIND FILE"))
        assert f.id == db.execute_query(
            "FIND FILE WHICH IS STORED AT testfiles/testfile",
            unique=True).id
        assert f.id == db.File(path='testfiles/testfile').retrieve().id
    
    
    def test_query3():
        body = get_connection().retrieve(
            entity_uri_segments=["Entity"], query_dict={
                "query": "bla"}, reconnect=True).read()
        print(body)
        xml = etree.fromstring(body)
        assert xml.xpath("/Response/TransactionBenchmark")
        assert xml.xpath("/Response/Query")
        assert xml.xpath("/Response/UserInfo")
        assert xml.xpath("/Response/noscript")
        assert xml.xpath("/Response/Error")
        assert 5 == len(xml)
    
    
    @mark.slow
    def test_conjunction():
        rt = db.RecordType(name="TestConjunctionTest").insert()
        assert rt.is_valid()
    
        pa = db.Property(
            name="TestConjunctionTestPropertyA",
            datatype="INTEGER").insert()
        assert pa.is_valid()
    
        pb = db.Property(
            name="TestConjunctionTestPropertyB",
            datatype="INTEGER").insert()
        assert pb.is_valid()
    
        ra = db.Record(
            name="TestA").add_parent(rt).add_property(
            property=pa,
            value="1").add_property(
                property=pb,
            value="0")
        rb = db.Record(
            name="TestB").add_parent(rt).add_property(
            property=pa,
            value="0").add_property(
                property=pb,
            value="1")
        rab = db.Record(
            name="TestAB").add_parent(rt).add_property(
            property=pa,
            value="1").add_property(
                property=pb,
            value="1")
        rn = db.Record(
            name="TestN").add_parent(rt).add_property(
            property=pa,
            value="0").add_property(
                property=pb,
            value="0")
        c = db.Container().extend([ra, rb, rab, rn]).insert()
        assert c.is_valid()
    
        assert 5 == len(db.execute_query("FIND TestConjunctionTest"))
    
        assert 4 == len(db.execute_query("FIND Record TestConjunctionTest"))
    
        assert 4 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA"))
        assert 4 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyB"))
        assert 2 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyB=1"))
        assert 2 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyB=0"))
        assert 2 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=1"))
        assert 2 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=0"))
    
        assert 1 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=1 AND TestConjunctionTestPropertyB=1"))
        assert 1 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=0 AND TestConjunctionTestPropertyB=0"))
        assert 1 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=0 AND TestConjunctionTestPropertyB=1"))
        assert 1 == len(db.execute_query(
            "FIND TestConjunctionTest . TestConjunctionTestPropertyA=1 AND TestConjunctionTestPropertyB=0"))
    
        assert 4 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyA"))
        assert 4 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyB"))
        assert 2 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyB=1"))
        assert 2 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyB=0"))
        assert 2 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyA=1"))
        assert 2 == len(db.execute_query(
            "FIND Record . TestConjunctionTestPropertyA=0"))
    
        assert 1 == len(db.execute_query(
            "FIND RECORD . TestConjunctionTestPropertyA=1 AND TestConjunctionTestPropertyB=1"))
        assert 1 == len(db.execute_query(
            "FIND RECORD . TestConjunctionTestPropertyA=0 AND TestConjunctionTestPropertyB=0"))
        assert 1 == len(db.execute_query(
            "FIND RECORD . TestConjunctionTestPropertyA=0 AND TestConjunctionTestPropertyB=1"))
        assert 1 == len(db.execute_query(
            "FIND RECORD . TestConjunctionTestPropertyA=1 AND TestConjunctionTestPropertyB=0"))
    
    
    @mark.slow
    def test_disjunction():
        rt = db.RecordType(name="TestDisjunctionTest").insert()
        assert rt.is_valid()
    
        pa = db.Property(
            name="TestDisjunctionTestPropertyA",
            datatype="INTEGER").insert()
        assert pa.is_valid()
    
        pb = db.Property(
            name="TestDisjunctionTestPropertyB",
            datatype="DOUBLE").insert()
        assert pb.is_valid()
    
        ra = db.Record(
            name="TestA").add_parent(rt).add_property(
            property=pa,
            value="1").add_property(
                property=pb,
            value="0")
        rb = db.Record(
            name="TestB").add_parent(rt).add_property(
            property=pa,
            value="0").add_property(
                property=pb,
            value="1")
        rab = db.Record(
            name="TestAB").add_parent(rt).add_property(
            property=pa,
            value="1").add_property(
                property=pb,
            value="1")
        rn = db.Record(
            name="TestN").add_parent(rt).add_property(
            property=pa,
            value="0").add_property(
                property=pb,
            value="0")
        c = db.Container().extend([ra, rb, rab, rn]).insert()
        assert c.is_valid()
    
        assert 5 == len(db.execute_query("FIND TestDisjunctionTest"))
    
        assert 4 == len(db.execute_query("FIND Record TestDisjunctionTest"))
    
        assert 4 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA"))
        assert 4 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyB"))
    
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyB=1"))
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyB=0"))
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=1"))
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=0"))
    
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=1 OR TestDisjunctionTestPropertyB=1"))
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=0 OR TestDisjunctionTestPropertyB=0"))
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=0 OR TestDisjunctionTestPropertyB=1"))
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=1 OR TestDisjunctionTestPropertyB=0"))
    
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . THE GREATEST TestDisjunctionTestPropertyB"))
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=1 OR THE GREATEST TestDisjunctionTestPropertyB"))
    
        assert rn.id == db.execute_query(
            "FIND TestDisjunctionTest .  TestDisjunctionTestPropertyA='-1' OR ( TestDisjunctionTestPropertyB=0 AND TestDisjunctionTestPropertyA=0)",
            unique=True).id
        assert 3 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=0 OR ( TestDisjunctionTestPropertyB=0 AND TestDisjunctionTestPropertyA=1)"))
        assert 2 == len(db.execute_query(
            "FIND TestDisjunctionTest . TestDisjunctionTestPropertyA=1 OR ( TestDisjunctionTestPropertyB=0 AND TestDisjunctionTestPropertyA=1)"))
    
    
    @mark.slow
    def test_greatest():
        pAB = db.Property(name="TestPropertyAB", datatype=db.DOUBLE).insert()
        assert pAB.is_valid()
        pA = db.Property(
            name="TestPropertyA",
            datatype=db.DOUBLE).add_parent(pAB).insert()
        assert pA.is_valid()
        pB = db.Property(name="TestPropertyB", datatype=db.DOUBLE).add_parent(pAB)
        assert len(pB.get_parents()) == 1
        print(pB)
        print(pB)
        pB.insert()
        assert pB.is_valid()
    
        rt = db.RecordType(name="TestRecordType").insert()
        assert rt.is_valid()
    
        rec1 = db.Record(name="TestRecord1").add_parent(
            rt).add_property(pA, value=1.0).insert()
        assert rec1.is_valid()
    
        c = db.execute_query(
            "FIND TestRecord1 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecord1 WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec1.id
    
        rec2 = db.Record(name="TestRecord2").add_parent(
            rt).add_property(pA, value=2.0).insert()
        assert rec2.is_valid()
    
        c = db.execute_query(
            "FIND TestRecord2 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecord1 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecord2 WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec2.id
    
        rec3 = db.Record(name="TestRecord3").add_parent(
            rt).add_property(pA, value=1.5).insert()
        assert rec3.is_valid()
    
        c = db.execute_query(
            "FIND TestRecord3 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec3.id
    
        c = db.execute_query(
            "FIND TestRecord2 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecord1 WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecord3 WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec3.id
    
        c = db.execute_query(
            "FIND TestRecord2 WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec2.id
    
        c = db.execute_query(
            "FIND TestRecord1 WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec1.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec2.id
    
        rec4 = db.Record(name="TestRecord4").add_parent(
            rt).add_property(pB, value=0.1).insert()
        assert rec4.is_valid()
    
        c = db.execute_query(
            "FIND TestRecord4 WHICH HAS THE GREATEST TestPropertyA")
        assert len(c) == 0
    
        c = db.execute_query(
            "FIND TestRecord4 WHICH HAS THE GREATEST TestPropertyB",
            unique=True)
        assert c.id == rec4.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyB",
            unique=True)
        assert c.id == rec4.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec2.id
    
        rec5 = db.Record(
            name="TestRecord5").add_parent(rt).add_property(
            pB,
            value=200).add_property(
                pA,
            value=1.5).insert()
        assert rec5.is_valid()
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec5.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyB",
            unique=True)
        assert c.id == rec5.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyA",
            unique=True)
        assert c.id == rec2.id
    
        rec6 = db.Record(
            name="TestRecord6").add_parent(rt).add_property(
            pAB,
            value=400).add_property(
                pB,
                value=100).add_property(
                    pA,
            value=2).insert()
        assert rec6.is_valid()
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyAB",
            unique=True)
        assert c.id == rec6.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyB",
            unique=True)
        assert c.id == rec5.id
    
        c = db.execute_query(
            "FIND TestRecordType WHICH HAS THE GREATEST TestPropertyA")
        assert c[0].id == rec2.id
        assert c[1].id == rec6.id
    
    
    def test_wildcard_values():
        ptext = db.Property(name="TestTextProperty", datatype=db.TEXT).insert()
        rt = db.RecordType(
            name="TestRecordType").add_property(
            ptext, value="abcdefg").insert()
    
        assert rt.is_valid()
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE "abc*"',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE abc*',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE abc*efg',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE abc*g',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE *',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE a*',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE *abc*',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE *fg',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE a*f*g',
            unique=True)
        assert rt2.id == rt.id
    
        rt2 = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE a*d*g',
            unique=True)
        assert rt2.id == rt.id
    
        c = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE abc')
        assert 0 == len(c)
    
        c = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty = abc*')
        assert 0 == len(c)
    
        c = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty = *abc*')
        assert 0 == len(c)
    
        c = db.execute_query(
            'FIND TestRecordType WHICH HAS A TestTextProperty LIKE *f')
        assert 0 == len(c)
    
    
    def store_file(path, name=None, f=None):
        """insert a file for testing purposes."""
        tmp_file = None
        if f is None:
            tmp_file = open("test.dat", "w")
            tmp_file.write("hello world\n")
            tmp_file.close()
            f = tmp_file
        if name is None:
            name = "TestFile%030x" % random.randrange(16**30)
    
        file_ = db.File(name=name,
                        description="Testfile Desc",
                        path=path,
                        file="test.dat")
        file_.insert()
    
        if tmp_file is not None:
            os.remove("test.dat")
        return file_
    
    
    def test_stored_at_wildcards():
    
        with open("test.dat", "w") as upload_file:
            upload_file.write("hello world\n")
    
        file1 = store_file("test1.dat", f=upload_file)
    
        file2 = store_file("/rootdir/test2.dat", f=upload_file)
    
        file3 = store_file("/rootdir/subdir1/test3.dat", f=upload_file)
    
        file4 = store_file("/rootdir/subdir1/subdir2/test4.dat", f=upload_file)
    
        file5 = store_file("test5.dat", f=upload_file)
    
        file6 = store_file("rootdir/test*6.dat", f=upload_file)
    
        file7 = store_file("rootdir/subdir1/test%7.dat", f=upload_file)
    
        file8 = store_file("rootdir/subdir1/test%8.dat", f=upload_file)
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT /*.dat")
        assert len(c) == 2
        assert c.get_entity_by_id(file1.id) is not None
        assert c.get_entity_by_id(file5.id) is not None
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT /**/subdir*/*.dat")
        assert len(c) == 4
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *subdir**.dat")
        assert len(c) == 4
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *subdir1**.dat")
        assert len(c) == 4
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *subdir2**.dat")
        assert len(c) == 1
        assert c.get_entity_by_id(file4.id) is not None
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT /rootdir/*.dat")
        assert len(c) == 2
        assert c.get_entity_by_id(file2.id) is not None
        assert c.get_entity_by_id(file6.id) is not None
    
        f = db.execute_query("FIND FILE WHICH IS STORED AT test1.dat", unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /test1.dat",
            unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT *test1.dat",
            unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /*test1.dat",
            unique=True)
        assert f.id == file1.id
    
        f = db.execute_query("FIND FILE WHICH IS STORED AT *1.dat", unique=True)
        assert f.id == file1.id
    
        f = db.execute_query("FIND FILE WHICH IS STORED AT /*1.dat", unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT **test1.dat",
            unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /**test1.dat",
            unique=True)
        assert f.id == file1.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT *rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /*rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT **rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /**rootdir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT *dir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /*dir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT **dir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        f = db.execute_query(
            "FIND FILE WHICH IS STORED AT /**dir/test2.dat",
            unique=True)
        assert f.id == file2.id
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *.dat")
        assert len(c) == 8
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *test*.dat")
        assert len(c) == 8
    
        c = db.execute_query("FIND FILE WHICH IS STORED AT *test%*.dat")
        assert len(c) == 2
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        f = db.execute_query(
            r"FIND FILE WHICH IS STORED AT *test\**.dat",
            unique=True)
        assert f.id == file6.id
    
        f = db.execute_query(
            r"FIND FILE WHICH IS STORED AT /rootdir/subdir1/subdir2/**",
            unique=True)
        assert f.id == file4.id
    
        f = db.execute_query(
            r"FIND FILE WHICH IS STORED AT '/rootdir/subdir1/subdir2/**'",
            unique=True)
        assert f.id == file4.id
    
        c = db.execute_query(
            r"FIND FILE WHICH IS STORED AT /rootdir/subdir1/**")
        assert len(c) == 4
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query(
            r"FIND FILE WHICH IS STORED AT '/rootdir/subdir1/**'")
        assert len(c) == 4
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query(
            r"FIND FILE WHICH IS STORED AT /rootdir/**")
        assert len(c) == 6
        assert c.get_entity_by_id(file2.id) is not None
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file6.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
        c = db.execute_query(
            r"FIND FILE WHICH IS STORED AT '/rootdir/**'")
        assert len(c) == 6
        assert c.get_entity_by_id(file2.id) is not None
        assert c.get_entity_by_id(file3.id) is not None
        assert c.get_entity_by_id(file4.id) is not None
        assert c.get_entity_by_id(file6.id) is not None
        assert c.get_entity_by_id(file7.id) is not None
        assert c.get_entity_by_id(file8.id) is not None
    
    
    @mark.slow
    def test_int():
        pint = db.Property(
            name="TestIntegerProperty",
            datatype=db.INTEGER).insert()
        pdouble = db.Property(
            name="TestDoubleProperty",
            datatype=db.DOUBLE).insert()
        db.RecordType(
            name="TestRecordType").add_property(
            pint,
            value="100").add_property(
                pdouble,
            value="100.5").insert()
    
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty>50",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty>=50",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty>=100",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty<=100",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty<=200",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty<200",
            unique=True)
    
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty>200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty>=200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty=200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty<50"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestIntegerProperty<=50"))
    
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty>50",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty>=50",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty>=100.5",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty=100.5",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty<=100.5",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty<=200",
            unique=True)
        db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty<200",
            unique=True)
    
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty>200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty>=200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty=200"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty<50"))
        assert 0 == len(db.execute_query(
            "FIND TestRecordType WITH TestDoubleProperty<=50"))
    
    
    def test_query_benchmark():
        db.Property("TestProperty", datatype=db.TEXT).insert()
    
        body = get_connection().retrieve(
            entity_uri_segments=["Entity"],
            query_dict={
                "query": "FIND TestProperty"},
            reconnect=True).read()
        print(body)
        xml = etree.fromstring(body)
        # see #4
        #assert 3 ==  len(xml)
        #assert "query" ==  xml[0].tag.lower()
        #assert "transactionbenchmark" ==  xml[0][3].tag.lower()
        #benchmark = xml[0][3]
        #assert len(benchmark) > 0
    
    
    def test_like_query():
        """ See https://git.goltzsche.net/caosdb/customers/glaz_awi/ext-awi/issues/1
        """
        db.execute_query("FIND box with number like '**'")
        db.execute_query("FIND box with number like 'a'")
        db.execute_query("FIND box with number like '*7*'")
        db.execute_query("FIND box with number like '7*'")
        db.execute_query("FIND box with number like '*7'")
        db.execute_query("FIND box with number like '7'")
        db.execute_query("FIND box with number = '7'")
    
    
    def test_backref_like():
        db.RecordType("TestData").insert()
        other = db.Record("other").add_parent("TestData").insert()
        sme = db.Record("s_m_e").add_property(
            "TestData", other.id).add_parent("TestData").insert()
        print(sme)
        db.execute_query("FIND ENTITY WHICH IS REFERENCED BY s_m_e", unique=True)
        db.execute_query("FIND ENTITY WHICH IS REFERENCED BY *m*", unique=True)
        db.execute_query("FIND ENTITY WHICH IS REFERENCED BY s*", unique=True)
        db.execute_query("FIND ENTITY WHICH IS REFERENCED BY *e", unique=True)
    
    
    def test_query_by_name():
        rt = db.RecordType("TestRT").insert()
        rec1 = db.Record("TestRec1").add_parent("TestRT").insert()
        rec2 = db.Record("TestRec2").add_parent("TestRT").insert()
    
        assert len(db.execute_query("FIND TestRT")) == 3
        assert len(db.execute_query("FIND RECORD TestRT")) == 2
        assert len(db.execute_query("FIND RECORDTYPE TestRT")) == 1
    
        # find rt via name
        assert db.execute_query("FIND RECORDTYPE WITH name = 'TestRT'",
                                unique=True).id == rt.id
        assert db.execute_query("FIND RECORDTYPE WITH NAME = 'TestRT'",
                                unique=True).id == rt.id
        assert db.execute_query("FIND RECORDTYPE WITH NAme = 'TestRT'",
                                unique=True).id == rt.id
        assert db.execute_query("FIND TestRT WITH NAme = 'TestRT'",
                                unique=True).id == rt.id
        assert db.execute_query("FIND RECORDTYPE WITH name LIKE Test*",
                                unique=True).id == rt.id
    
        # find rec1 via name
        assert db.execute_query("FIND TestRT WITH name = 'TestRec1'",
                                unique=True).id == rec1.id
        assert db.execute_query("FIND RECORD TestRT WITH name = 'TestRec1'",
                                unique=True).id == rec1.id
        assert db.execute_query("FIND RECORD TestRT WITH name LIKE '*Rec1'",
                                unique=True).id == rec1.id
    
        # find both records via name
        assert len(db.execute_query("FIND TestRT WITH name LIKE 'TestRec*'")) == 2
        assert len(db.execute_query("FIND TestRT WITH name LIKE '*Rec*'")) == 2
        assert len(db.execute_query("FIND ENTITY WITH name LIKE 'TestRec*'")) == 2
    
    
    @mark.xfail(reason="Issue: https://gitlab.com/caosdb/caosdb-server/-/issues/96")
    def test_referenced_as():
        rt_person = db.RecordType("TestPerson").insert()
        db.RecordType("TestParty").insert()
    
        # three persons
        g1 = db.Record().add_parent("TestPerson").insert()
        g2 = db.Record().add_parent("TestPerson").insert()
        g3 = db.Record().add_parent("TestPerson").insert()
        guest_ids = set(g1.id, g2.id, g3.id)
    
        party = db.Record(
            "Diamond Jubilee of Elizabeth II").add_parent("TestParty")
        party.add_property(rt_person, datatype=db.LIST(rt_person), name="Guests",
                           value=[g1, g2, g3])
        party.insert()
        guests = db.execute_query("FIND RECORD TestPerson WHICH IS REFERENCED BY "
                                  "TestParty AS Guests")
        assert len(guests) == 3
        assert set([e.id for e in guests]) == guest_ids
    
    
    def test_query_cache():
        entity = db.RecordType("TestRT").insert()
    
        # fill cache
        query = db.Query("COUNT TestRT")
        assert query.cached is None
        response = query.execute()
        assert response == 1
        assert query.cached == False
        assert query.etag is not None
        etag = query.etag
    
        # cached == True
        query = db.Query("COUNT TestRT")
        assert query.cached is None
        response = query.execute()
        assert response == 1
        assert query.cached == True
        assert query.etag == etag
    
        # cached == True
        query = db.Query("FIND TestRT")
        assert query.cached is None
        response = query.execute(unique=True)
        assert response.id == entity.id
        assert query.cached == True
        assert query.etag == etag
    
        # cached == True
        query = db.Query("SELECT bla FROM TestRT")
        assert query.cached is None
        response = query.execute(unique=True)
        assert response.id == entity.id
        assert query.cached == True
        assert query.etag == etag
    
        # no cache flag
        query = db.Query("SELECT bla FROM TestRT")
        assert query.cached is None
        response = query.execute(unique=True, cache=False)
        assert response.id == entity.id
        assert query.cached == False
        assert query.etag == etag
    
        # cached == True
        query = db.Query("SELECT bla FROM TestRT")
        assert query.cached is None
        response = query.execute(unique=True)
        assert response.id == entity.id
        assert query.cached == True
        assert query.etag == etag
    
        # write resets cache
        another_entity = db.Record().add_parent("TestRT").insert()
    
        # cached == False
        query = db.Query("COUNT TestRT")
        assert query.cached is None
        response = query.execute()
        assert response == 2
        assert query.cached == False
        assert query.etag != etag
        new_etag = query.etag
    
        # cached == True
        query = db.Query("COUNT TestRT")
        assert query.cached is None
        response = query.execute()
        assert response == 2
        assert query.cached == True
        assert query.etag == new_etag
    
    
    def test_query_cache_with_permissions():
        db.RecordType("TestRT").insert()
        db.RecordType("TestRT2").insert()
        public_record = db.Record().add_parent("TestRT").insert()
        referenced = db.Record().add_parent("TestRT2").insert()
        private_record = db.Record().add_parent(
            "TestRT").add_property("TestRT2",
                                   referenced).insert(flags={"ACL": None})
    
        # proof: query as anonymous works in principle
        db.configure_connection(password_method="unauthenticated")
        query = db.Query("COUNT Record TestRT")
        response = query.execute()
        assert response == 2
        assert query.cached == False
    
        query = db.Query("COUNT Record WHICH IS REFERENCED BY TestRT")
        response = query.execute()
        assert response == 1
        assert query.cached == False
    
        # remove permissions for anonymous
        db.configure_connection()
        private_record.deny(role="anonymous", permission="RETRIEVE:*")
        private_record.update_acl()  # note: this clears the cache
    
        # as authenticated user to fill the cache
        query = db.Query("COUNT Record TestRT")
        response = query.execute()
        assert response == 2
        assert query.cached == False
    
        query = db.Query("COUNT Record WHICH IS REFERENCED BY TestRT")
        response = query.execute()
        assert response == 1
        assert query.cached == False
    
        # as anonymous
        db.configure_connection(password_method="unauthenticated")
        query = db.Query("COUNT Record TestRT")
        response = query.execute()
        assert response == 1
        assert query.cached == True
    
        query = db.Query("COUNT Record WHICH IS REFERENCED BY TestRT")
        response = query.execute()
        assert response == 0
        # Caching was not possible due to complex permissions
        assert query.cached == False
    
        # try again as authenticated user
        db.configure_connection()
        query = db.Query("COUNT Record TestRT")
        response = query.execute()
        assert query.cached == True
        assert response == 2
    
        query = db.Query("COUNT Record WHICH IS REFERENCED BY TestRT")
        response = query.execute()
        assert response == 1
        # Caching was not possible due to complex permissions
        assert query.cached == False
    
    
    def test_find_star():
        """related: caosdb-server#116"""
        rt = db.RecordType("TestRT").insert()
        response = db.execute_query("FIND *")[0]
        assert response.id == rt.id
    
    
    def test_find_entity():
        rt = db.RecordType("TestRT").insert()
        response = db.execute_query("FIND ENTITY")[0]
        assert response.id == rt.id
    
    
    def test_count_any_version_of_entity():
        vcount1 = db.execute_query("COUNT ANY VERSION OF ENTITY")
        ecount1 = db.execute_query("COUNT ENTITY")
        assert ecount1 == 0
        assert vcount1 == 0
    
        rt = db.RecordType("TestRT").insert()
        vcount2 = db.execute_query("COUNT ANY VERSION OF ENTITY")
        ecount2 = db.execute_query("COUNT ENTITY")
        assert vcount2 == vcount1 + 1
        assert ecount2 == ecount1 + 1
    
        rt.description = "update"
        rt.update()
        vcount3 = db.execute_query("COUNT ANY VERSION OF ENTITY")
        ecount3 = db.execute_query("COUNT ENTITY")
        assert vcount3 == vcount2 + 1
        assert ecount3 == ecount2
    
    
    def test_find_nasty_path():
        """related: caosdb-server#31"""
        file_1 = store_file("0in.txt")
        assert db.execute_query(
            "FIND FILE WHICH IS STORED AT 0in.txt",
            unique=True).id == file_1.id
    
        file_2 = store_file(".asdf.txt")
        assert db.execute_query(
            "FIND FILE WHICH IS STORED AT .asdf.txt",
            unique=True).id == file_2.id
    
        file_3 = store_file(".WITH")
        assert db.execute_query(
            "FIND FILE WHICH IS STORED AT .WITH",
            unique=True).id == file_3.id
    
        file_4 = store_file("STORED")
        assert db.execute_query(
            "FIND FILE WHICH IS STORED AT STORED",
            unique=True).id == file_4.id
    
        file_5 = store_file("STORED AT")  # hehe
        assert db.execute_query(
            "FIND FILE WHICH IS STORED AT STORED AT",
            unique=True).id == file_5.id
    
    
    def test_transaction_time():
        rt = db.RecordType("TestRT").insert(flags={"H": None})
        date = rt.version.date
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED AT " + date,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED AFTER " + date,
                             unique=True)
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED BEFORE " + date,
                             unique=True)
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED SINCE " + date,
            unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED UNTIL " + date,
            unique=True).id
    
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED AFTER TODAY",
                             unique=True)
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED BEFORE TODAY",
                             unique=True)
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED SINCE TODAY",
            unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED UNTIL TODAY",
            unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED TODAY",
            unique=True).id
    
        year = date[:4]
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED IN " + year,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED AFTER " + year,
                             unique=True)
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED BEFORE " + year,
                             unique=True)
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED SINCE " + year,
            unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED UNTIL " + year,
            unique=True).id
    
        old_year = "2020"
        with raises(EmptyUniqueQueryError):
            db.execute_query(
                "FIND TestRT WHICH WAS INSERTED IN " + old_year,
                unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED AFTER " + old_year,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED BEFORE " + old_year,
                             unique=True)
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED SINCE " + old_year,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED UNTIL " + old_year,
                             unique=True)
    
        next_year = str(int(year) + 1)
        with raises(EmptyUniqueQueryError):
            db.execute_query(
                "FIND TestRT WHICH WAS INSERTED IN " + next_year,
                unique=True).id
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED BEFORE " + next_year,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED AFTER " + next_year,
                             unique=True)
        assert rt.id == db.execute_query(
            "FIND TestRT WHICH WAS INSERTED UNTIL " + next_year,
            unique=True).id
        with raises(EmptyUniqueQueryError):
            db.execute_query("FIND TestRT WHICH WAS INSERTED SINCE " + next_year,
                             unique=True)