U
    DAf                     @   s  d dl Z d dlmZ d dlmZ d dlZd dlmZ d dlm	Z	 d dl
mZmZ d dlmZ d dlmZ ed	Zd dlZW 5 Q R X d
d ZedZedZG dd dZG dd dZG dd deZG dd dZG dd dZG dd deeZG dd deeZG dd deeZG dd deeZG dd  d eeZG d!d" d"eeZ G d#d$ d$eeZ!G d%d& d&eeZ"G d'd( d(eeZ#G d)d* d*eeZ$G d+d, d,eeZ%G d-d. d.eeeeee e!e"e#e$e%Z&G d/d0 d0eeZ'G d1d2 d2eeee'Z(dS )3    N)datetime)List)Document)DuplicateDocumentError)DocumentStoreDuplicatePolicy)FilterError)
LazyImportzRun 'pip install pytest'c                 C   s   dd t | D S )Nc                 S   s   g | ]}t   qS  )random).0_r
   r
   C/tmp/pip-unpacked-wheel-z752163x/haystack/testing/document_store.py
<listcomp>   s     z&_random_embeddings.<locals>.<listcomp>)range)nr
   r
   r   _random_embeddings   s    r      c                   @   s$   e Zd Zee ee dddZdS )AssertDocumentsEqualMixin)receivedexpectedc                 C   s   ||kst dS )a  
        Assert that two lists of Documents are equal.

        This is used in every test, if a Document Store implementation has a different behaviour
        it should override this method. This can happen for example when the Document Store sets
        a score to returned Documents. Since we can't know what the score will be, we can't compare
        the Documents reliably.
        N)AssertionError)selfr   r   r
   r
   r   assert_documents_are_equal$   s    	z4AssertDocumentsEqualMixin.assert_documents_are_equalN)__name__
__module____qualname__r   r   r   r
   r
   r
   r   r   #   s   r   c                   @   s,   e Zd ZdZedddZedddZdS )CountDocumentsTestay  
    Utility class to test a Document Store `count_documents` method.

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(CountDocumentsTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    document_storec                 C   s   |  dkstdS )z.Test count is zero for an empty document storer   N)count_documentsr   r   r   r
   r
   r   test_count_empty?   s    z#CountDocumentsTest.test_count_emptyc                 C   s6   | tddtddtddg | dks2tdS )zHTest count is greater than zero if the document store contains documents
test doc 1content
test doc 2z
test doc 3   N)write_documentsr   r    r   r!   r
   r
   r   test_count_not_emptyC   s    z'CountDocumentsTest.test_count_not_emptyN)r   r   r   __doc__r   r"   r)   r
   r
   r
   r   r   0   s   r   c                   @   sV   e Zd ZdZedddZedddZedddZedd	d
ZedddZ	dS )WriteDocumentsTesta  
    Utility class to test a Document Store `write_documents` method.

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    The Document Store `filter_documents` method must be at least partly implemented to return all stored Documents
    for this tests to work correctly.
    Example usage:

    ```python
    class MyDocumentStoreTest(WriteDocumentsTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    r   c                 C   s   d}t |dS )z;
        Test write_documents() default behaviour.
        zDefault write_documents() behaviour depends on the Document Store implementation, as we don't enforce a default behaviour when no policy is set. Override this test in your custom test class.NNotImplementedError)r   r   msgr
   r
   r   test_write_documents\   s    z'WriteDocumentsTest.test_write_documentsc              	   C   sb   t dd}|j|gtjddks$ttt |j|gtjd W 5 Q R X | |	 |g dS )z\Test write_documents() fails when writing documents with same id and `DuplicatePolicy.FAIL`.test docr$   policy   	documentsr2   N)
r   r(   r   FAILr   pytestraisesr   r   filter_documentsr   r   docr
   r
   r   #test_write_documents_duplicate_failg   s
    
z6WriteDocumentsTest.test_write_documents_duplicate_failc                 C   sB   t dd}|j|gtjddks$t|j|gtjddks>tdS )zETest write_documents() skips writing when using DuplicatePolicy.SKIP.r0   r$   r1   r3   r4   r   N)r   r(   r   ZSKIPr   r:   r
   r
   r   #test_write_documents_duplicate_skipo   s    
z6WriteDocumentsTest.test_write_documents_duplicate_skipc                 C   st   t ddd}t ddd}|j|gtjddks2t| | |g |j|gtjddks^t| | |g dS )	zGTest write_documents() overwrites when using DuplicatePolicy.OVERWRITE.1r#   )idr%   r&   r1   r3   r4   N)r   r(   r   Z	OVERWRITEr   r   r9   )r   r   Zdoc1Zdoc2r
   r
   r   (test_write_documents_duplicate_overwriteu   s    z;WriteDocumentsTest.test_write_documents_duplicate_overwritec              	   C   sF   t t |dg W 5 Q R X t t |d W 5 Q R X dS )z=Test write_documents() fails when providing unexpected input.znot a document for sureznot a list actuallyN)r7   r8   
ValueErrorr(   r!   r
   r
   r   "test_write_documents_invalid_input   s    z5WriteDocumentsTest.test_write_documents_invalid_inputN)
r   r   r   r*   r   r/   r<   r=   r@   rB   r
   r
   r
   r   r+   K   s   
r+   c                   @   s:   e Zd ZdZedddZedddZedddZd	S )
DeleteDocumentsTesta  
    Utility class to test a Document Store `delete_documents` method.

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    The Document Store `write_documents` and `count_documents` methods must be implemented for this tests to work
    correctly.
    Example usage:

    ```python
    class MyDocumentStoreTest(DeleteDocumentsTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    r   c                 C   sH   t dd}||g | dks&t||jg | dksDtdS )z)Test delete_documents() normal behaviour.r0   r$   r3   r   N)r   r(   r    r   delete_documentsr?   r:   r
   r
   r   test_delete_documents   s
    
z)DeleteDocumentsTest.test_delete_documentsc                 C   s   | dg dS )zOTest delete_documents() doesn't fail when called using an empty Document Store.non_existing_idN)rD   r!   r
   r
   r   *test_delete_documents_empty_document_store   s    z>DeleteDocumentsTest.test_delete_documents_empty_document_storec                 C   sF   t dd}||g | dks&t|dg | dksBtdS )zUTest delete_documents() doesn't delete any Document when called with non existing id.r0   r$   r3   rF   N)r   r(   r    r   rD   r:   r
   r
   r   +test_delete_documents_non_existing_document   s
    
z?DeleteDocumentsTest.test_delete_documents_non_existing_documentN)r   r   r   r*   r   rE   rG   rH   r
   r
   r
   r   rC      s   	rC   c                   @   s(   e Zd ZdZejee dddZdS )FilterableDocsFixtureMixinzL
    Mixin class that adds a filterable_docs() fixture to a test class.
    returnc                 C   s4  g }t dD ] }|td| d| dddddtd	d
 |td| d| dddddtd	d
 |td| d| dddddtd	d
 |td| dd| dddd |tt|gdd| id |td| ddditd
 |td| d dd!itd
 q|S )"zLFixture that returns a list of Documents that can be used to test filtering.r'   zA Foo Document Zname_100intro   1969-07-21T20:17:40)namepagechapternumberdater   )r%   meta	embeddingzA Bar Document 123abstract1972-12-11T19:54:58zA Foobar Document Z90Z
conclusionz1989-11-09T17:53:00z	Document z without embeddingT)rP   Zno_embeddingrR   )r%   rU   rP   Z
table_doc_)	dataframerU   zDoc z with zeros embZ	zeros_docz with ones embZones_doc)r   appendr   r   pd	DataFrameTEST_EMBEDDING_1TEST_EMBEDDING_2)r   r5   ir
   r
   r   filterable_docs   sh    
$z*FilterableDocsFixtureMixin.filterable_docsN)	r   r   r   r*   r7   fixturer   r   rc   r
   r
   r
   r   rI      s   rI   c                   @   sL   e Zd ZdZeee dddZeee dddZeee dddZ	d	S )
'LegacyFilterDocumentsInvalidFiltersTesta  
    Utility class to test a Document Store `filter_documents` method using invalid legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsInvalidFiltersTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    r   rc   c              	   C   s0   | | tt |jdd W 5 Q R X dS ) zsomething oddfiltersN)r(   r7   r8   rA   r9   r   r   rc   r
   r
   r   test_incorrect_filter_type  s    
zBLegacyFilterDocumentsInvalidFiltersTest.test_incorrect_filter_typec              	   C   s8   | | tt |jdddiid W 5 Q R X dS )rg   rS   rQ   rL   rh   Nr(   r7   r8   r   r9   rj   r
   r
   r   test_incorrect_filter_nesting  s    
zELegacyFilterDocumentsInvalidFiltersTest.test_incorrect_filter_nestingc              	   C   s<   | | tt |jddddiiid W 5 Q R X dS )rg   rS   rQ   rR   rM   rh   Nrl   rj   r
   r
   r   $test_deeper_incorrect_filter_nesting  s    
zLLegacyFilterDocumentsInvalidFiltersTest.test_deeper_incorrect_filter_nestingN)
r   r   r   r*   r   r   r   rk   rm   rn   r
   r
   r
   r   re      s   re   c                   @   s   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
eee dddZeee dddZeee dddZdS )LegacyFilterDocumentsEqualTesta  
    Utility class to test a Document Store `filter_documents` method using implicit and explicit '$eq' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsEqualTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s4   | | |jddid}| |dd |D  dS )rg   r%   A Foo Document 1rh   c                 S   s   g | ]}|j d kr|qS )rp   r$   r   r;   r
   r
   r   r   '  s     
 zOLegacyFilterDocumentsEqualTest.test_filter_document_content.<locals>.<listcomp>Nr(   r9   r   r   r   rc   resultr
   r
   r   test_filter_document_content#  s    
z;LegacyFilterDocumentsEqualTest.test_filter_document_contentc                 C   s4   | | |jddid}| |dd |D  dS )rg   rQ   rL   rh   c                 S   s    g | ]}|j d dkr|qS rQ   rL   rU   getrq   r
   r
   r   r   -  s      zTLegacyFilterDocumentsEqualTest.test_filter_simple_metadata_value.<locals>.<listcomp>Nrr   rs   r
   r
   r   !test_filter_simple_metadata_value)  s    
z@LegacyFilterDocumentsEqualTest.test_filter_simple_metadata_valuec                 C   s<   | | |jdtdgid}| |dd |D  dS )rg   r\   r3   rh   c                 S   s.   g | ]&}|j d k	r|j tdgr|qS Nr3   r\   equalsr^   r_   rq   r
   r
   r   r   5  s     
  zQLegacyFilterDocumentsEqualTest.test_filter_document_dataframe.<locals>.<listcomp>Nr(   r9   r^   r_   r   rs   r
   r
   r   test_filter_document_dataframe/  s    
z=LegacyFilterDocumentsEqualTest.test_filter_document_dataframec                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rQ   $eqrL   rh   c                 S   s    g | ]}|j d dkr|qS rv   rw   rq   r
   r
   r   r   <  s      zJLegacyFilterDocumentsEqualTest.test_eq_filter_explicit.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_eq_filter_explicit8  s    
z6LegacyFilterDocumentsEqualTest.test_eq_filter_explicitc                 C   s4   | | |jddid}| |dd |D  dS )rg   rQ   rL   rh   c                 S   s    g | ]}|j d dkr|qS rv   rw   rq   r
   r
   r   r   B  s      zJLegacyFilterDocumentsEqualTest.test_eq_filter_implicit.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_eq_filter_implicit>  s    
z6LegacyFilterDocumentsEqualTest.test_eq_filter_implicitc                 C   s<   | | |jdtdgid}| |dd |D  dS )rg   r\   r3   rh   c                 S   s2   g | ]*}t |jtjr|jtd gr|qS r3   
isinstancer\   r^   r_   r|   rq   r
   r
   r   r   J  s    zGLegacyFilterDocumentsEqualTest.test_eq_filter_table.<locals>.<listcomp>Nr}   rs   r
   r
   r   test_eq_filter_tableD  s    
z3LegacyFilterDocumentsEqualTest.test_eq_filter_tablec                    sB   | | dgd  |jd id}| | fdd|D  dS )rg           r   rV   rh   c                    s   g | ]} |j kr|qS r
   rV   rq   r   r
   r   r   V  s     
 zKLegacyFilterDocumentsEqualTest.test_eq_filter_embedding.<locals>.<listcomp>Nrr   rs   r
   r   r   test_eq_filter_embeddingQ  s    

z7LegacyFilterDocumentsEqualTest.test_eq_filter_embeddingN)r   r   r   r*   r   r   r   ru   ry   r~   r   r   r   r   r
   r
   r
   r   ro     s   	ro   c                   @   sL   e Zd ZdZeee dddZeee dddZeee dddZ	d	S )
!LegacyFilterDocumentsNotEqualTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$ne' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsNotEqualTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rQ   $nerL   rh   c                 S   s    g | ]}|j d dkr|qS rv   rw   rq   r
   r
   r   r   l  s      zDLegacyFilterDocumentsNotEqualTest.test_ne_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_ne_filterh  s    
z0LegacyFilterDocumentsNotEqualTest.test_ne_filterc                 C   s@   | | |jddtdgiid}| |dd |D  dS )rg   r\   r   r3   rh   c                 S   s2   g | ]*}t |jtjr*|jtd gs|qS r   r   rq   r
   r
   r   r   t  s    zJLegacyFilterDocumentsNotEqualTest.test_ne_filter_table.<locals>.<listcomp>Nr}   rs   r
   r
   r   test_ne_filter_tablen  s    
z6LegacyFilterDocumentsNotEqualTest.test_ne_filter_tablec                 C   s8   | | |jddtiid}| |dd |D  dS )rg   rV   r   rh   c                 S   s   g | ]}|j tkr|qS r
   )rV   r`   rq   r
   r
   r   r     s     
 zNLegacyFilterDocumentsNotEqualTest.test_ne_filter_embedding.<locals>.<listcomp>N)r(   r9   r`   r   rs   r
   r
   r   test_ne_filter_embedding{  s    
z:LegacyFilterDocumentsNotEqualTest.test_ne_filter_embeddingN)
r   r   r   r*   r   r   r   r   r   r   r
   r
   r
   r   r   Y  s   r   c                   @   s   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
eee dddZeee dddZeee dddZeee dddZeee dddZdS )LegacyFilterDocumentsInTesta  
    Utility class to test a Document Store `filter_documents` method using implicit and explicit '$in' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsInTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s6   | | |jddgid}| |dd |D  dS )rg   rQ   rL   rh   c                 S   s    g | ]}|j d dkr|qS rv   rw   rq   r
   r
   r   r     s      zVLegacyFilterDocumentsInTest.test_filter_simple_list_single_element.<locals>.<listcomp>Nrr   rs   r
   r
   r   &test_filter_simple_list_single_element  s    
zBLegacyFilterDocumentsInTest.test_filter_simple_list_single_elementc                 C   s6   | | |jddgid}| |dd |D  dS )rg   rQ   rL   rh   c                 S   s    g | ]}|j d dkr|qS )rQ   )rL   rw   rq   r
   r
   r   r     s      zQLegacyFilterDocumentsInTest.test_filter_simple_list_one_value.<locals>.<listcomp>Nrr   rs   r
   r
   r   !test_filter_simple_list_one_value  s    
z=LegacyFilterDocumentsInTest.test_filter_simple_list_one_valuec                 C   s8   | | |jdddgid}| |dd |D  dS )rg   rQ   rL   rW   rh   c                 S   s    g | ]}|j d dkr|qS rQ   )rL   rW   rw   rq   r
   r
   r   r     s      zGLegacyFilterDocumentsInTest.test_filter_simple_list.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_filter_simple_list  s    
 z3LegacyFilterDocumentsInTest.test_filter_simple_listc                 C   s,   | | |jddgid}| |g  dS )rg   Znon_existing_meta_fieldZwhateverrh   Nrr   rs   r
   r
   r   test_incorrect_filter_name  s    
z6LegacyFilterDocumentsInTest.test_incorrect_filter_namec                 C   s,   | | |jddgid}| |g  dS )rg   rQ   Znoperh   Nrr   rs   r
   r
   r   test_incorrect_filter_value  s    
z7LegacyFilterDocumentsInTest.test_incorrect_filter_valuec                 C   s>   | | |jdddddgiid}| |dd |D  d	S )
rg   rQ   $inrL   rW   n.a.rh   c                 S   s    g | ]}|j d dkr|qS r   rw   rq   r
   r
   r   r     s      zGLegacyFilterDocumentsInTest.test_in_filter_explicit.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_in_filter_explicit  s    
 z3LegacyFilterDocumentsInTest.test_in_filter_explicitc                 C   s:   | | |jddddgid}| |dd |D  dS )	rg   rQ   rL   rW   r   rh   c                 S   s    g | ]}|j d dkr|qS r   rw   rq   r
   r
   r   r     s      zGLegacyFilterDocumentsInTest.test_in_filter_implicit.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_in_filter_implicit  s    
 z3LegacyFilterDocumentsInTest.test_in_filter_implicitc                 C   sL   | | |jddtdgtdggiid}| |dd |D  dS )	rg   r\   r   r3   rN   rh   c                 S   sF   g | ]>}t |jtjr|jtd gs>|jtdgr|qS )r3   rN   r   rq   r
   r
   r   r     s
    zDLegacyFilterDocumentsInTest.test_in_filter_table.<locals>.<listcomp>Nr}   rs   r
   r
   r   test_in_filter_table  s    
(z0LegacyFilterDocumentsInTest.test_in_filter_tablec                    sV   | | dgd dgd  |jdd giid}| | fdd|D  d	S )
rg   r   r         ?rV   r   rh   c                    s$   g | ]}|j ks |j kr|qS r
   r   rq   Zembedding_oneZembedding_zeror
   r   r     s     
 
 zHLegacyFilterDocumentsInTest.test_in_filter_embedding.<locals>.<listcomp>Nrr   rs   r
   r   r   test_in_filter_embedding  s    


z4LegacyFilterDocumentsInTest.test_in_filter_embeddingN)r   r   r   r*   r   r   r   r   r   r   r   r   r   r   r   r   r
   r
   r
   r   r     s   r   c                   @   sL   e Zd ZdZeee dddZeee dddZeee dddZ	d	S )
LegacyFilterDocumentsNotInTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$nin' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsNotInTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   sL   | | |jddtdgtdggiid}| |dd |D  dS )	rg   r\   $ninr3   r   rh   c                 S   sF   g | ]>}t |jtjr>|jtd gs|jtdgs|qS )r3   r   r   rq   r
   r
   r   r     s
    zHLegacyFilterDocumentsNotInTest.test_nin_filter_table.<locals>.<listcomp>Nr}   rs   r
   r
   r   test_nin_filter_table  s    
z4LegacyFilterDocumentsNotInTest.test_nin_filter_tablec                 C   s<   | | |jddttgiid}| |dd |D  dS )rg   rV   r   rh   c                 S   s   g | ]}|j ttfkr|qS r
   )rV   r`   ra   rq   r
   r
   r   r     s      zLLegacyFilterDocumentsNotInTest.test_nin_filter_embedding.<locals>.<listcomp>N)r(   r9   r`   ra   r   rs   r
   r
   r   test_nin_filter_embedding  s    
 z8LegacyFilterDocumentsNotInTest.test_nin_filter_embeddingc                 C   s>   | | |jdddddgiid}| |dd |D  d	S )
rg   rQ   r   rL   rW   r   rh   c                 S   s    g | ]}|j d dkr|qS r   rw   rq   r
   r
   r   r     s      zBLegacyFilterDocumentsNotInTest.test_nin_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_nin_filter  s    
 z.LegacyFilterDocumentsNotInTest.test_nin_filterN)
r   r   r   r*   r   r   r   r   r   r   r
   r
   r
   r   r     s   r   c                   @   s`   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
dS )$LegacyFilterDocumentsGreaterThanTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$gt' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsGreaterThanTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rS   $gtr   rh   c                 S   s(   g | ] }d |j kr|j d  dkr|qS )rS   r   rU   rq   r
   r
   r   r     s     
  zGLegacyFilterDocumentsGreaterThanTest.test_gt_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_gt_filter  s    
 z3LegacyFilterDocumentsGreaterThanTest.test_gt_filterc              	   C   s8   | | tt |jdddiid W 5 Q R X dS )rg   rQ   r   rL   rh   Nrl   rj   r
   r
   r   test_gt_filter_non_numeric"  s    
z?LegacyFilterDocumentsGreaterThanTest.test_gt_filter_non_numericc              
   C   sN   | | tt0 |jddtdddgdddggiid	 W 5 Q R X d
S )rg   r\   r   r3   rN   r'   rY   rh   Nr(   r7   r8   r   r9   r^   r_   rj   r
   r
   r   test_gt_filter_table(  s    
z9LegacyFilterDocumentsGreaterThanTest.test_gt_filter_tablec              	   C   s8   | | tt |jddtiid W 5 Q R X dS )rg   rV   r   rh   Nr(   r7   r8   r   r9   r`   rj   r
   r
   r   test_gt_filter_embedding.  s    
z=LegacyFilterDocumentsGreaterThanTest.test_gt_filter_embeddingN)r   r   r   r*   r   r   r   r   r   r   r   r
   r
   r
   r   r     s
   r   c                   @   s`   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
dS ))LegacyFilterDocumentsGreaterThanEqualTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$gte' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsGreaterThanEqualTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rS   $gterY   rh   c                 S   s(   g | ] }d |j kr|j d  dkr|qS )rS   rY   r   rq   r
   r
   r   r   I  s     
  zMLegacyFilterDocumentsGreaterThanEqualTest.test_gte_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_gte_filterD  s    
 z9LegacyFilterDocumentsGreaterThanEqualTest.test_gte_filterc              	   C   s8   | | tt |jdddiid W 5 Q R X dS )rg   rQ   r   rL   rh   Nrl   rj   r
   r
   r   test_gte_filter_non_numericL  s    
zELegacyFilterDocumentsGreaterThanEqualTest.test_gte_filter_non_numericc              
   C   sN   | | tt0 |jddtdddgdddggiid	 W 5 Q R X d
S )rg   r\   r   r3   rN   r'   r   rY   r   rh   Nr   rj   r
   r
   r   test_gte_filter_tableR  s    
z?LegacyFilterDocumentsGreaterThanEqualTest.test_gte_filter_tablec              	   C   s8   | | tt |jddtiid W 5 Q R X dS )rg   rV   r   rh   Nr   rj   r
   r
   r   test_gte_filter_embeddingX  s    
zCLegacyFilterDocumentsGreaterThanEqualTest.test_gte_filter_embeddingN)r   r   r   r*   r   r   r   r   r   r   r   r
   r
   r
   r   r   5  s
   r   c                   @   s`   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
dS )!LegacyFilterDocumentsLessThanTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$lt' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsLessThanTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rS   $ltr   rh   c                 S   s.   g | ]&}|j d dk	r|j d  dk r|qS rS   Nr   rw   rq   r
   r
   r   r   s  s       zDLegacyFilterDocumentsLessThanTest.test_lt_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_lt_filtern  s    
 z0LegacyFilterDocumentsLessThanTest.test_lt_filterc              	   C   s8   | | tt |jdddiid W 5 Q R X dS )rg   rQ   r   rL   rh   Nrl   rj   r
   r
   r   test_lt_filter_non_numericv  s    
z<LegacyFilterDocumentsLessThanTest.test_lt_filter_non_numericc              
   C   sN   | | tt0 |jddtdddgdddggiid	 W 5 Q R X d
S )rg   r\   r   r3   rN   r'   r   rY   r   rh   Nr   rj   r
   r
   r   test_lt_filter_table|  s    
z6LegacyFilterDocumentsLessThanTest.test_lt_filter_tablec              	   C   s8   | | tt |jddtiid W 5 Q R X dS )rg   rV   r   rh   N)r(   r7   r8   r   r9   ra   rj   r
   r
   r   test_lt_filter_embedding  s    
z:LegacyFilterDocumentsLessThanTest.test_lt_filter_embeddingN)r   r   r   r*   r   r   r   r   r   r   r   r
   r
   r
   r   r   _  s
   r   c                   @   s`   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
dS )&LegacyFilterDocumentsLessThanEqualTesta  
    Utility class to test a Document Store `filter_documents` method using explicit '$lte' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsLessThanEqualTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   s8   | | |jdddiid}| |dd |D  dS )rg   rS   $lte       @rh   c                 S   s.   g | ]&}|j d dk	r|j d  dkr|qS )rS   Nr   rw   rq   r
   r
   r   r     s       zJLegacyFilterDocumentsLessThanEqualTest.test_lte_filter.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_lte_filter  s    
 z6LegacyFilterDocumentsLessThanEqualTest.test_lte_filterc              	   C   s8   | | tt |jdddiid W 5 Q R X dS )rg   rQ   r   rL   rh   Nrl   rj   r
   r
   r   test_lte_filter_non_numeric  s    
zBLegacyFilterDocumentsLessThanEqualTest.test_lte_filter_non_numericc              
   C   sN   | | tt0 |jddtdddgdddggiid	 W 5 Q R X d
S )rg   r\   r   r3   rN   r'   r   rY   r   rh   Nr   rj   r
   r
   r   test_lte_filter_table  s    
z<LegacyFilterDocumentsLessThanEqualTest.test_lte_filter_tablec              	   C   s8   | | tt |jddtiid W 5 Q R X dS )rg   rV   r   rh   Nr   rj   r
   r
   r   test_lte_filter_embedding  s    
z@LegacyFilterDocumentsLessThanEqualTest.test_lte_filter_embeddingN)r   r   r   r*   r   r   r   r   r   r   r   r
   r
   r
   r   r     s
   r   c                   @   s`   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
dS )&LegacyFilterDocumentsSimpleLogicalTesta  
    Utility class to test a Document Store `filter_documents` method using '$and', '$or' and '$not' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsSimpleLogicalTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   sJ   | | ddddgiddidi}|j|d}| |d	d
 |D  dS )rg   $orr   name_0name_1r   r   rP   rS   rh   c                 S   s>   g | ]6}|j d dk	r&|j d  dk s6|j ddkr|qS )rS   Nr3   rP   r   r   rw   rq   r
   r
   r   r     s
    zPLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_or.<locals>.<listcomp>Nrr   r   r   rc   ri   rt   r
   r
   r   test_filter_simple_or  s    
z<LegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_orc                 C   s:   | | |jddddid}| |dd |D  dS )	rg   rS   r   r   r   r   rh   c                 S   s6   g | ].}d |j kr|j d  dkr|j d  dkr|qS )rS   r   r   r   rq   r
   r
   r   r     s
   
  znLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_implicit_and_with_multi_key_dict.<locals>.<listcomp>Nrr   rs   r
   r
   r   3test_filter_simple_implicit_and_with_multi_key_dict  s    
zZLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_implicit_and_with_multi_key_dictc                 C   sD   | | |jddddiddigiid}| |dd	 |D  d
S )rg   rS   $andr   rN   r   r   rh   c                 S   s6   g | ].}d |j kr|j d  dkr|j d  dkr|qS rS   r   r   r   rq   r
   r
   r   r     s
   
  zdLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_explicit_and_with_list.<locals>.<listcomp>Nrr   rs   r
   r
   r   )test_filter_simple_explicit_and_with_list  s    
 zPLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_explicit_and_with_listc                 C   s:   | | |jddddid}| |dd |D  dS )	rg   rS   r   r   r   rh   c                 S   s6   g | ].}d |j kr|j d  dkr|j d  dkr|qS r   r   rq   r
   r
   r   r     s
   
  zZLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_implicit_and.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_filter_simple_implicit_and  s    
zFLegacyFilterDocumentsSimpleLogicalTest.test_filter_simple_implicit_andN)r   r   r   r*   r   r   r   r   r   r   r   r
   r
   r
   r   r     s    r   c                   @   s   e Zd ZdZeee dddZeee dddZeee dddZ	eee dd	d
Z
eee dddZeee dddZdS )&LegacyFilterDocumentsNestedLogicalTesta  
    Utility class to test `filter_documents` using multiple nested logical '$and', '$or' and '$not' legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsNestedLogicalTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    rf   c                 C   sD   | | dddddgd}|j|d}| |dd	 |D  d
S )rg   rN   r   r   r   r   )rS   rP   rh   c                 S   sF   g | ]>}d |j kr|j d  dkr|j d  dkr|j ddkr|qS )rS   rN   r   rP   r   rw   rq   r
   r
   r   r     s   
zZLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_implicit_and.<locals>.<listcomp>Nrr   r   r   rc   Zfilters_simplifiedrt   r
   r
   r   test_filter_nested_implicit_and
  s    
zFLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_implicit_andc                 C   sR   | | ddddiddigiddidi}|j|d}| |d	d
 |D  dS )rg   r   r   r   r   r   r   r   rh   c                 S   s>   g | ]6}|j d dks6|j ddk	r|j d dk r|qS )rP   r   rS   Nr3   rw   rq   r
   r
   r   r   $  s
    zPLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_or.<locals>.<listcomp>Nrr   r   r
   r
   r   test_filter_nested_or  s    
"z<LegacyFilterDocumentsNestedLogicalTest.test_filter_nested_orc                 C   sT   | | dddidddgiddid	d
i}|j|d}| |dd |D  dS )rg   r   r   rW   r   r   r   r   r   r   rQ   r   rh   c                 S   sH   g | ]@}|j d dkr|j ddks@d|j kr|j d dk r|qS rQ   )rW   rP   r   rS   r3   rw   rq   r
   r
   r   r   7  s   
 z]LegacyFilterDocumentsNestedLogicalTest.test_filter_nested_and_or_explicit.<locals>.<listcomp>Nrr   r   r
   r
   r   "test_filter_nested_and_or_explicit.  s    
 zILegacyFilterDocumentsNestedLogicalTest.test_filter_nested_and_or_explicitc                 C   sP   | | ddidddgiddidd	}|j|d
}| |dd |D  dS )rg   r   rW   r   r   r   r   r   r   r   rh   c                 S   sH   g | ]@}|j d dkr|j ddks@d|j kr|j d dk r|qS r   rw   rq   r
   r
   r   r   N  s   
 z]LegacyFilterDocumentsNestedLogicalTest.test_filter_nested_and_or_implicit.<locals>.<listcomp>Nrr   r   r
   r
   r   "test_filter_nested_and_or_implicitD  s    
zILegacyFilterDocumentsNestedLogicalTest.test_filter_nested_and_or_implicitc                 C   sX   | | dddidddgiddd	iid
di}|j|d}| |dd |D  dS )rg   r   r   r3   r   r   r   rR   r   rM   )rP   z$not)rS   r   rh   c                 S   sN   g | ]F}|j d dk	r&|j d  dk sF|j ddkr|j ddkr|qS )rS   Nr3   rP   r   rR   rM   rw   rq   r
   r
   r   r   g  s     zTLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_or_and.<locals>.<listcomp>Nrr   r   r
   r
   r   test_filter_nested_or_and[  s    
z@LegacyFilterDocumentsNestedLogicalTest.test_filter_nested_or_andc                 C   s`   | | dddddgiddidddd	gid
digi}|j|d}| |dd |D  dS )rg   r   r   r   r   r   rL   )rP   rQ   rM   rX   rW   )rR   rQ   rh   c                 S   sP   g | ]H}|j d dkr(|j ddksH|j ddkr|j ddkr|qS )rP   r   rQ   rL   rR   )rM   rX   rW   rw   rq   r
   r
   r   r     s     zuLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_multiple_identical_operators_same_level.<locals>.<listcomp>Nrr   r   r
   r
   r   :test_filter_nested_multiple_identical_operators_same_levelq  s    
zaLegacyFilterDocumentsNestedLogicalTest.test_filter_nested_multiple_identical_operators_same_levelN)r   r   r   r*   r   r   r   r   r   r   r   r   r   r
   r
   r
   r   r     s    r   c                   @   s,   e Zd ZdZedddZedddZdS )LegacyFilterDocumentsTesta  
    Utility class to test a Document Store `filter_documents` method using different types of legacy filters

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(LegacyFilterDocumentsTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    r   c                 C   s(   |  g kst|j i dg ks$tdS )rg   rh   N)r9   r   r!   r
   r
   r   test_no_filter_empty  s    z.LegacyFilterDocumentsTest.test_no_filter_emptyc                 C   s>   t ddg}|| | |ks&t|ji d|ks:tdS )rg   r0   r$   rh   N)r   r(   r9   r   r   r   Zdocsr
   r
   r   test_no_filter_not_empty  s    
z2LegacyFilterDocumentsTest.test_no_filter_not_emptyN)r   r   r   r*   r   r   r   r
   r
   r
   r   r     s   r   c                   @   sx  e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Zd4d5 Zd6d7 Zd8d9 Zd:d; Z d<d= Z!d>d? Z"d@dA Z#dBdC Z$dDdE Z%dFdG Z&dHdI Z'dJdK Z(dLdM Z)dNdO Z*dPdQ Z+dRdS Z,dTdU Z-dVdW Z.dXdY Z/dZd[ Z0d\S )]FilterDocumentsTesta  
    Utility class to test a Document Store `filter_documents` method using different types of  filters.

    To use it create a custom test class and override the `document_store` fixture to return your Document Store.
    Example usage:

    ```python
    class MyDocumentStoreTest(FilterDocumentsTest):
        @pytest.fixture
        def document_store(self):
            return MyDocumentStore()
    ```
    c                 C   sb   |  | g  |  |ji dg  tddg}|| |  | | |  |ji d| dS )z*Test filter_documents() with empty filtersrh   r0   r$   N)r   r9   r   r(   r   r
   r
   r   test_no_filters  s    
z#FilterDocumentsTest.test_no_filtersc                 C   s8   | | |jddddd}| |dd |D  dS )	z*Test filter_documents() with == comparatormeta.number==d   fieldoperatorvaluerh   c                 S   s    g | ]}|j d dkr|qS rS   r   rw   r   dr
   r
   r   r     s      z=FilterDocumentsTest.test_comparison_equal.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_equal  s    
z)FilterDocumentsTest.test_comparison_equalc                 C   s@   | | |jddtdgdd}| |dd |D  dS )	z8Test filter_documents() with == comparator and dataframer\   r   r3   r   rh   c                 S   s.   g | ]&}|j d k	r|j tdgr|qS rz   r{   r   r
   r
   r   r     s     
  zLFilterDocumentsTest.test_comparison_equal_with_dataframe.<locals>.<listcomp>Nr}   rs   r
   r
   r   $test_comparison_equal_with_dataframe  s    
 z8FilterDocumentsTest.test_comparison_equal_with_dataframec                 C   s8   | | |jddddd}| |dd |D  dS )z3Test filter_documents() with == comparator and Noner   r   Nr   rh   c                 S   s    g | ]}|j d dkr|qS rS   Nrw   r   r
   r
   r   r     s      zGFilterDocumentsTest.test_comparison_equal_with_none.<locals>.<listcomp>rr   rs   r
   r
   r   test_comparison_equal_with_none  s    
z3FilterDocumentsTest.test_comparison_equal_with_nonec                 C   s6   | | |dddd}| |dd |D  dS )z*Test filter_documents() with != comparatorr   !=r   r   c                 S   s    g | ]}|j d dkr|qS r   rw   r   r
   r
   r   r     s      zAFilterDocumentsTest.test_comparison_not_equal.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_not_equal  s    
z-FilterDocumentsTest.test_comparison_not_equalc                 C   s@   | | |jddtdgdd}| |dd |D  dS )	z8Test filter_documents() with != comparator and dataframer\   r   r3   r   rh   c                 S   s.   g | ]&}|j d ks&|j tdgs|qS rz   r{   r   r
   r
   r   r     s     
  zPFilterDocumentsTest.test_comparison_not_equal_with_dataframe.<locals>.<listcomp>Nr}   rs   r
   r
   r   (test_comparison_not_equal_with_dataframe  s    
 z<FilterDocumentsTest.test_comparison_not_equal_with_dataframec                 C   s8   | | |jddddd}| |dd |D  dS )z3Test filter_documents() with != comparator and Noner   r   Nr   rh   c                 S   s    g | ]}|j d dk	r|qS r   rw   r   r
   r
   r   r     s      zKFilterDocumentsTest.test_comparison_not_equal_with_none.<locals>.<listcomp>rr   rs   r
   r
   r   #test_comparison_not_equal_with_none  s    
z7FilterDocumentsTest.test_comparison_not_equal_with_nonec                 C   s6   | | |dddd}| |dd |D  dS )z)Test filter_documents() with > comparatorr   >r   r   c                 S   s.   g | ]&}|j d dk	r|j d  dkr|qS r   rw   r   r
   r
   r   r     s       zDFilterDocumentsTest.test_comparison_greater_than.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_greater_than  s    
 z0FilterDocumentsTest.test_comparison_greater_thanc                 C   s6   | | |dddd}| |dd |D  dS )z6Test filter_documents() with > comparator and datetime	meta.dater   rZ   r   c                 S   s:   g | ]2}|j d dk	rt|j d  tdkr|qS )rT   NrZ   rU   rx   r   fromisoformatr   r
   r
   r   r   	  s   zRFilterDocumentsTest.test_comparison_greater_than_with_iso_date.<locals>.<listcomp>Nrr   rs   r
   r
   r   *test_comparison_greater_than_with_iso_date  s    

z>FilterDocumentsTest.test_comparison_greater_than_with_iso_datec              	   C   s8   | | tt |jddddd W 5 Q R X dS )z4Test filter_documents() with > comparator and stringr   r   r>   r   rh   Nrl   rj   r
   r
   r   (test_comparison_greater_than_with_string  s    
z<FilterDocumentsTest.test_comparison_greater_than_with_stringc              	   C   s@   | | tt" |jddtdgdd W 5 Q R X dS )z7Test filter_documents() with > comparator and dataframer\   r   r3   r   rh   Nr   rj   r
   r
   r   +test_comparison_greater_than_with_dataframe  s    
z?FilterDocumentsTest.test_comparison_greater_than_with_dataframec              	   C   s:   | | tt |jdddgdd W 5 Q R X dS )z2Test filter_documents() with > comparator and listr   r   r3   r   rh   Nrl   rj   r
   r
   r   &test_comparison_greater_than_with_list  s    
z:FilterDocumentsTest.test_comparison_greater_than_with_listc                 C   s.   | | |jddddd}| |g  dS )z2Test filter_documents() with > comparator and Noner   r   Nr   rh   rr   rs   r
   r
   r   &test_comparison_greater_than_with_none#  s    
z:FilterDocumentsTest.test_comparison_greater_than_with_nonec                 C   s6   | | |dddd}| |dd |D  dS )z*Test filter_documents() with >= comparatorr   >=r   r   c                 S   s.   g | ]&}|j d dk	r|j d  dkr|qS r   rw   r   r
   r
   r   r   /  s       zJFilterDocumentsTest.test_comparison_greater_than_equal.<locals>.<listcomp>Nrr   rs   r
   r
   r   "test_comparison_greater_than_equal*  s    
 z6FilterDocumentsTest.test_comparison_greater_than_equalc                 C   s6   | | |dddd}| |dd |D  dS )z7Test filter_documents() with >= comparator and datetimer   r   rO   r   c                 S   s:   g | ]2}|j d dk	rt|j d  tdkr|qS rT   NrO   r   r   r
   r
   r   r   :  s   zXFilterDocumentsTest.test_comparison_greater_than_equal_with_iso_date.<locals>.<listcomp>Nrr   rs   r
   r
   r   0test_comparison_greater_than_equal_with_iso_date2  s    

zDFilterDocumentsTest.test_comparison_greater_than_equal_with_iso_datec              	   C   s8   | | tt |jddddd W 5 Q R X dS )z5Test filter_documents() with >= comparator and stringr   r   r>   r   rh   Nrl   rj   r
   r
   r   .test_comparison_greater_than_equal_with_stringB  s    
zBFilterDocumentsTest.test_comparison_greater_than_equal_with_stringc              	   C   s@   | | tt" |jddtdgdd W 5 Q R X dS )z8Test filter_documents() with >= comparator and dataframer\   r   r3   r   rh   Nr   rj   r
   r
   r   1test_comparison_greater_than_equal_with_dataframeH  s
    
zEFilterDocumentsTest.test_comparison_greater_than_equal_with_dataframec              	   C   s:   | | tt |jdddgdd W 5 Q R X dS )z3Test filter_documents() with >= comparator and listr   r   r3   r   rh   Nrl   rj   r
   r
   r   ,test_comparison_greater_than_equal_with_listP  s    
z@FilterDocumentsTest.test_comparison_greater_than_equal_with_listc                 C   s.   | | |jddddd}| |g  dS )z3Test filter_documents() with >= comparator and Noner   r   Nr   rh   rr   rs   r
   r
   r   ,test_comparison_greater_than_equal_with_noneV  s    
z@FilterDocumentsTest.test_comparison_greater_than_equal_with_nonec                 C   s6   | | |dddd}| |dd |D  dS )z)Test filter_documents() with < comparatorr   <r   r   c                 S   s.   g | ]&}|j d dk	r|j d  dk r|qS r   rw   r   r
   r
   r   r   b  s       zAFilterDocumentsTest.test_comparison_less_than.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_less_than]  s    
 z-FilterDocumentsTest.test_comparison_less_thanc                 C   s6   | | |dddd}| |dd |D  dS )z6Test filter_documents() with < comparator and datetimer   r  rO   r   c                 S   s:   g | ]2}|j d dk	rt|j d  tdk r|qS r   r   r   r
   r
   r   r   m  s   zOFilterDocumentsTest.test_comparison_less_than_with_iso_date.<locals>.<listcomp>Nrr   rs   r
   r
   r   'test_comparison_less_than_with_iso_datee  s    

z;FilterDocumentsTest.test_comparison_less_than_with_iso_datec              	   C   s8   | | tt |jddddd W 5 Q R X dS )z4Test filter_documents() with < comparator and stringr   r  r>   r   rh   Nrl   rj   r
   r
   r   %test_comparison_less_than_with_stringu  s    
z9FilterDocumentsTest.test_comparison_less_than_with_stringc              	   C   s@   | | tt" |jddtdgdd W 5 Q R X dS )z7Test filter_documents() with < comparator and dataframer\   r  r3   r   rh   Nr   rj   r
   r
   r   (test_comparison_less_than_with_dataframe{  s    
z<FilterDocumentsTest.test_comparison_less_than_with_dataframec              	   C   s:   | | tt |jdddgdd W 5 Q R X dS )z2Test filter_documents() with < comparator and listr   r  r3   r   rh   Nrl   rj   r
   r
   r   #test_comparison_less_than_with_list  s    
z7FilterDocumentsTest.test_comparison_less_than_with_listc                 C   s.   | | |jddddd}| |g  dS )z2Test filter_documents() with < comparator and Noner   r  Nr   rh   rr   rs   r
   r
   r   #test_comparison_less_than_with_none  s    
z7FilterDocumentsTest.test_comparison_less_than_with_nonec                 C   s6   | | |dddd}| |dd |D  dS )zTest filter_documents() with <=r   <=r   r   c                 S   s.   g | ]&}|j d dk	r|j d  dkr|qS r   rw   r   r
   r
   r   r     s       zGFilterDocumentsTest.test_comparison_less_than_equal.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_less_than_equal  s    
 z3FilterDocumentsTest.test_comparison_less_than_equalc                 C   s6   | | |dddd}| |dd |D  dS )z7Test filter_documents() with <= comparator and datetimer   r
  rO   r   c                 S   s:   g | ]2}|j d dk	rt|j d  tdkr|qS r   r   r   r
   r
   r   r     s   zUFilterDocumentsTest.test_comparison_less_than_equal_with_iso_date.<locals>.<listcomp>Nrr   rs   r
   r
   r   -test_comparison_less_than_equal_with_iso_date  s    

zAFilterDocumentsTest.test_comparison_less_than_equal_with_iso_datec              	   C   s8   | | tt |jddddd W 5 Q R X dS )z5Test filter_documents() with <= comparator and stringr   r
  r>   r   rh   Nrl   rj   r
   r
   r   +test_comparison_less_than_equal_with_string  s    
z?FilterDocumentsTest.test_comparison_less_than_equal_with_stringc              	   C   s@   | | tt" |jddtdgdd W 5 Q R X dS )z8Test filter_documents() with <= comparator and dataframer\   r
  r3   r   rh   Nr   rj   r
   r
   r   .test_comparison_less_than_equal_with_dataframe  s
    
zBFilterDocumentsTest.test_comparison_less_than_equal_with_dataframec              	   C   s:   | | tt |jdddgdd W 5 Q R X dS )z3Test filter_documents() with <= comparator and listr   r
  r3   r   rh   Nrl   rj   r
   r
   r   )test_comparison_less_than_equal_with_list  s    
z=FilterDocumentsTest.test_comparison_less_than_equal_with_listc                 C   s.   | | |jddddd}| |g  dS )z3Test filter_documents() with <= comparator and Noner   r
  Nr   rh   rr   rs   r
   r
   r   )test_comparison_less_than_equal_with_none  s    
z=FilterDocumentsTest.test_comparison_less_than_equal_with_nonec                 C   sJ   | | |ddddgd}t|s,tdd |D }| || dS )	z,Test filter_documents() with 'in' comparatorr   in
   r[   r   c                 S   s.   g | ]&}|j d dk	r|j d  dkr|qS )rS   N)r  r[   rw   r   r
   r
   r   r     s       z:FilterDocumentsTest.test_comparison_in.<locals>.<listcomp>N)r(   r9   lenr   r   )r   r   rc   rt   r   r
   r
   r   test_comparison_in  s
    
z&FilterDocumentsTest.test_comparison_inc              	   C   s6   | | tt |dddd W 5 Q R X dS )z=Test filter_documents() with 'in' comparator and non-iterabler   r  	   r   Nrl   rj   r
   r
   r   %test_comparison_in_with_with_non_list  s    
z9FilterDocumentsTest.test_comparison_in_with_with_non_listc              	   C   s6   | | tt |dddd W 5 Q R X dS )z9Test filter_documents() with 'in' comparator and iterabler   r  r     r   Nrl   rj   r
   r
   r   .test_comparison_in_with_with_non_list_iterable  s    
zBFilterDocumentsTest.test_comparison_in_with_with_non_list_iterablec                 C   s:   | | |ddddgd}| |dd |D  dS )	z0Test filter_documents() with 'not in' comparatorr   not inr  r  r   c                 S   s    g | ]}|j d dkr|qS )rS   )r  r  rw   r   r
   r
   r   r     s      z>FilterDocumentsTest.test_comparison_not_in.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_comparison_not_in  s    
z*FilterDocumentsTest.test_comparison_not_inc              	   C   s6   | | tt |dddd W 5 Q R X dS )zATest filter_documents() with 'not in' comparator and non-iterabler   r  r  r   Nrl   rj   r
   r
   r   )test_comparison_not_in_with_with_non_list  s    
z=FilterDocumentsTest.test_comparison_not_in_with_with_non_listc              	   C   s6   | | tt |dddd W 5 Q R X dS )z=Test filter_documents() with 'not in' comparator and iterabler   r  r  r   Nrl   rj   r
   r
   r   2test_comparison_not_in_with_with_non_list_iterable  s    
zFFilterDocumentsTest.test_comparison_not_in_with_with_non_list_iterablec                 C   sJ   | | |jdddddddddgdd	}| |d
d |D  dS )z+Test filter_documents() with 'AND' operatorANDr   r   r   r   	meta.namer   r   
conditionsrh   c                 S   s0   g | ](}|j d dkr|j ddkr|qS rS   r   rP   r   rw   r   r
   r
   r   r     s       z9FilterDocumentsTest.test_and_operator.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_and_operator  s    


	 z%FilterDocumentsTest.test_and_operatorc                 C   sJ   | | |jdddddddddgdd	}| |d
d |D  dS )z*Test filter_documents() with 'OR' operatorORr   r   r   r   r  r   r   rh   c                 S   s0   g | ](}|j d dks(|j ddkr|qS r"  rw   r   r
   r
   r   r     s       z8FilterDocumentsTest.test_or_operator.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_or_operator  s    


	 z$FilterDocumentsTest.test_or_operatorc                 C   sJ   | | |jdddddddddgdd	}| |d
d |D  dS )z+Test filter_documents() with 'NOT' operatorZNOTr   r   r   r   r  r   r   rh   c                 S   s0   g | ](}|j d dkr(|j ddks|qS r"  rw   r   r
   r
   r   r     s       z9FilterDocumentsTest.test_not_operator.<locals>.<listcomp>Nrr   rs   r
   r
   r   test_not_operator	  s    


	 z%FilterDocumentsTest.test_not_operatorc              	   C   s>   | | tt  |jdddddgid W 5 Q R X dS )z/Test filter_documents() with top-level operatorr!  r  r   testr   rh   Nrl   rj   r
   r
   r   #test_missing_top_level_operator_key  s
    
z7FilterDocumentsTest.test_missing_top_level_operator_keyc              	   C   s4   | | tt |jddid W 5 Q R X dS )z<Test filter_documents() with missing top-level condition keyr   r  rh   Nrl   rj   r
   r
   r   %test_missing_top_level_conditions_key"  s    
z9FilterDocumentsTest.test_missing_top_level_conditions_keyc              	   C   s>   | | tt  |jddddgdd W 5 Q R X dS )z2Test filter_documents() with missing condition keyr  r   r'  )r   r   r   rh   Nrl   rj   r
   r
   r    test_missing_condition_field_key(  s
    
z4FilterDocumentsTest.test_missing_condition_field_keyc              	   C   s>   | | tt  |jddddgdd W 5 Q R X dS )z1Test filter_documents() with missing operator keyr  r  r'  )r   r   r   rh   Nrl   rj   r
   r
   r   #test_missing_condition_operator_key0  s
    
z7FilterDocumentsTest.test_missing_condition_operator_keyc              	   C   s>   | | tt  |jddddgdd W 5 Q R X dS )z4Test filter_documents() with missing condition valuer  r  r   )r   r   r   rh   Nrl   rj   r
   r
   r    test_missing_condition_value_key8  s
    
z4FilterDocumentsTest.test_missing_condition_value_keyN)1r   r   r   r*   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r	  r  r  r  r  r  r  r  r  r  r  r  r  r#  r%  r&  r(  r)  r*  r+  r,  r
   r
   r
   r   r     s\   


r   c                   @   s    e Zd ZejedddZdS )DocumentStoreBaseTestsrJ   c                 C   s
   t  dS )zKBase fixture, to be reimplemented when deriving from DocumentStoreBaseTestsNr,   )r   r
   r
   r   r   B  s    z%DocumentStoreBaseTests.document_storeN)r   r   r   r7   rd   r   r   r
   r
   r
   r   r-  A  s   r-  ))r   r   typingr   Zpandasr^   Zhaystack.dataclassesr   Zhaystack.document_stores.errorsr   Zhaystack.document_stores.typesr   r   Zhaystack.errorsr   Zhaystack.lazy_importsr	   Zpytest_importr7   r   r`   ra   r   r   r+   rC   rI   re   ro   r   r   r   r   r   r   r   r   r   r   r   r-  r
   r
   r
   r   <module>   s`   

<*A"E)Y0****H 
(   