def test_not_in_condition(self): qc = OJAIQueryCondition().not_in_( 'age', [20, 21, 22, 23, 24, 25]).close().build() self.assertEqual(qc.as_dictionary(), {'$notin': { 'age': [20, 21, 22, 23, 24, 25] }})
def test_query_condition_multiple_is(self): qc = OJAIQueryCondition().is_('age', QueryOp.GREATER_OR_EQUAL, 55).is_('age', QueryOp.NOT_EQUAL, 18) \ .close().build() self.assertEqual(qc.as_dictionary(), { '$ge': { 'age': 55 }, '$ne': { 'age': 18 } })
def test_empty_condition(self): qc = OJAIQueryCondition() self.assertTrue(qc.is_empty()) qc.is_('name', QueryOp.EQUAL, 'Doe').close() self.assertTrue(qc.is_empty()) qc.build() self.assertFalse(qc.is_empty())
def test_check_and_update(self): connection = ConnectionFactory.get_connection( connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) if connection.is_store_exists(store_path=UpdateTest.store_name): document_store = connection.get_store( store_path=UpdateTest.store_name) else: document_store = connection.create_store( store_path=UpdateTest.store_name) self.assertEqual( { '_id': 'id02', 'mystr': 'str', 'test_int': 51, 'test_str': 'strstr' }, document_store.find_by_id('id02')) mutation = OJAIDocumentMutation().set_or_replace( 'new_field', { 'd': 55, 'g': 'text' }) from mapr.ojai.ojai_query.OJAIQueryCondition import OJAIQueryCondition false_condition = OJAIQueryCondition().equals_( 'test_str', 'rtsrts').close().build() self.assertFalse( document_store.check_and_update('id02', mutation=mutation, query_condition=false_condition)) self.assertEqual( { '_id': 'id02', 'mystr': 'str', 'test_int': 51, 'test_str': 'strstr' }, document_store.find_by_id('id02')) true_condition = OJAIQueryCondition().equals_( 'test_str', 'strstr').close().build() document_store.check_and_update('id02', mutation=mutation, query_condition=true_condition) self.assertEqual( { '_id': 'id02', 'mystr': 'str', 'test_int': 51, 'test_str': 'strstr', 'new_field': { 'd': 55, 'g': 'text' } }, document_store.find_by_id('id02'))
def test_eq_condition(self): qc = OJAIQueryCondition().and_().not_equals_('name', 'Joh').equals_( 'name', 'David').close().build() self.assertEqual( qc.as_dictionary(), {'$and': [{ '$ne': { 'name': 'Joh' } }, { '$eq': { 'name': 'David' } }]})
def test_check_and_delete_false_condition(self): connection = ConnectionFactory.get_connection( connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) if connection.is_store_exists(store_path='/check-delete-test-store1'): document_store = connection.get_store( store_path='/check-delete-test-store1') else: document_store = connection.create_store( store_path='/check-delete-test-store1') before_action = document_store.find_by_id('id07') self.assertEqual(before_action, { '_id': 'id07', 'test_int': 51, 'test_str': 'strstr' }) document_store.check_and_delete( 'id06', OJAIQueryCondition().is_('test_int', QueryOp.LESS_OR_EQUAL, 50).close().build()) after_action = document_store.find_by_id('id07') self.assertEqual(after_action, { '_id': 'id07', 'test_int': 51, 'test_str': 'strstr' })
def test_check_and_replace_false_condition(self): connection = ConnectionFactory.get_connection( connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) if connection.is_store_exists(store_path='/check-replace-test-store1'): document_store = connection.get_store( store_path='/check-replace-test-store1') else: document_store = connection.create_store( store_path='/check-replace-test-store1') before_action = document_store.find_by_id('id06') self.assertEqual(before_action, { '_id': 'id06', 'new_field': 123, 'new_array': [1, 2, 3] }) new_document = connection.new_document().set_id('id06').set( 'false_field', 321).set('false_array', [5, 5, 5]) condition = OJAIQueryCondition().or_().is_('test_int', QueryOp.GREATER_OR_EQUAL, 60)\ .is_('test_str', QueryOp.EQUAL, 'falsestr')\ .close().build() document_store.check_and_replace(new_document, condition) after_action = document_store.find_by_id('id06') self.assertEqual(after_action, { '_id': 'id06', 'new_field': 123, 'new_array': [1, 2, 3] })
def test_check_and_delete(self): connection = ConnectionFactory.get_connection( connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) if connection.is_store_exists(store_path='/check-delete-test-store1'): document_store = connection.get_store( store_path='/check-delete-test-store1') else: document_store = connection.create_store( store_path='/check-delete-test-store1') for doc in DICT_STREAM: document_store.insert_or_replace(doc=connection.new_document( dictionary=doc)) before_action = document_store.find_by_id('id06') self.assertEqual(before_action, { '_id': 'id06', 'test_int': 51, 'test_str': 'strstr' }) document_store.check_and_delete( 'id06', OJAIQueryCondition().is_('test_int', QueryOp.LESS_OR_EQUAL, 52).close().build()) after_action = document_store.find_by_id('id06') self.assertEqual(after_action, {})
def test_full_query(self): qc = OJAIQueryCondition().and_() \ .condition_(OJAIQueryCondition() .or_() .is_('age', QueryOp.GREATER_OR_EQUAL, 22) .is_('city', QueryOp.EQUAL, 'NY').close()) \ .condition_(OJAIQueryCondition() .and_() .is_('age', QueryOp.GREATER_OR_EQUAL, 18) .is_('city', QueryOp.EQUAL, 'London').close()).close().build() query = OJAIQuery().select( 'name', 'age', 'city').where(qc).order_by('name').offset(500).limit(5).build() self.assertEqual( query.query_dict(), { '$orderby': { 'name': 'asc' }, '$offset': 500, '$select': ['name', 'age', 'city'], '$limit': 5, '$where': { '$and': [{ '$or': [{ '$ge': { 'age': 22 } }, { '$eq': { 'city': 'NY' } }] }, { '$and': [{ '$ge': { 'age': 18 } }, { '$eq': { 'city': 'London' } }] }] } })
def test_condition(self): query_condition = OJAIQueryCondition() \ .and_() \ .is_('age', QueryOp.GREATER_OR_EQUAL, 18) \ .is_('city', QueryOp.EQUAL, 'London').close().close() query_condition.build() self.assertEqual( query_condition.as_dictionary(), {'$and': [{ '$ge': { 'age': 18 } }, { '$eq': { 'city': 'London' } }]})
def test_and_with_separate_is(self): qc = OJAIQueryCondition() \ .and_() \ .and_() \ .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=18) \ .is_(field_path='city', op=QueryOp.EQUAL, value='London') \ .close() \ .and_() \ .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=22) \ .is_(field_path='city', op=QueryOp.EQUAL, value='NY') \ .close() \ .is_('card', QueryOp.EQUAL, 'visa') \ .close() qc.build() self.assertEqual( qc.as_dictionary(), { '$and': [{ '$and': [{ '$ge': { 'age': 18 } }, { '$eq': { 'city': 'London' } }] }, { '$and': [{ '$ge': { 'age': 22 } }, { '$eq': { 'city': 'NY' } }] }, { '$eq': { 'card': 'visa' } }] })
def test_find_by_id_with_condition(self): connection = ConnectionFactory.get_connection(connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) if connection.is_store_exists(store_path='/find-by-id-test-store1'): document_store = connection.get_store(store_path='/find-by-id-test-store1') else: document_store = connection.create_store(store_path='/find-by-id-test-store1') self.assertTrue(connection.is_store_exists('/find-by-id-test-store1')) condition = OJAIQueryCondition().exists_('false_field').close().build() doc = document_store.find_by_id('id008', condition=condition, results_as_document=True) self.assertEqual(doc.as_dictionary(), {}) condition = OJAIQueryCondition().exists_('test_list').close().build() doc = document_store.find_by_id('id008', condition=condition, results_as_document=True, field_paths=['test_null', 'test_dict', '_id', 'test_str']) self.assertEqual(doc.as_dictionary(), {'_id': 'id008', 'test_dict': {'test_int': 5}, 'test_null': None, 'test_str': 'strstr'})
def test_incompatible_str_type(self): from mapr.ojai.ojai_query.OJAIQuery import OJAIQuery from mapr.ojai.ojai_query.OJAIQueryCondition import OJAIQueryCondition id_field = '_id' try: condition = OJAIQueryCondition().equals_(id_field, id_field).close().build() query = OJAIQuery().select([id_field]) except BaseException: self.fail("Probably incompatible str type.")
def test_element_and(self): query_condition = OJAIQueryCondition() \ .element_and('grades[]') \ .equals_('dsc', 'history') \ .equals_('ev', 12) \ .close() \ .build() self.assertEqual( { '$elementAnd': { 'grades[]': [{ '$eq': { 'dsc': 'history' } }, { '$eq': { 'ev': 12 } }] } }, query_condition.as_dictionary())
def test_empty_where(self): with self.assertRaises(AttributeError): OJAIQuery().where({}).build() with self.assertRaises(AttributeError): OJAIQuery().where('').build() with self.assertRaises(AttributeError): OJAIQuery().where(u'').build() with self.assertRaises(AttributeError): OJAIQuery().where(OJAIQueryCondition().build()).build()
def test_query_condition_dict(self): condition_to_add = OJAIQueryCondition() \ .or_() \ .is_('age', QueryOp.GREATER_OR_EQUAL, 21) \ .is_('city', QueryOp.EQUAL, 'NY') \ .close().build() qc = OJAIQueryCondition() \ .or_() \ .condition_(condition_to_add.as_dictionary()) \ .is_('age', QueryOp.GREATER_OR_EQUAL, 18).close().build() self.assertEqual( qc.as_dictionary(), { '$or': [{ '$or': [{ '$ge': { 'age': 21 } }, { '$eq': { 'city': 'NY' } }] }, { '$ge': { 'age': 18 } }] })
def test_nested_and(self): qc = OJAIQueryCondition().and_() \ .is_(field_path='card', op=QueryOp.NOT_EQUAL, value="visa") \ .or_() \ .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=22) \ .is_(field_path='city', op=QueryOp.EQUAL, value='NY') \ .and_() \ .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=18) \ .is_(field_path='city', op=QueryOp.EQUAL, value='London').close().close().close().build() self.assertEqual( qc.as_dictionary(), { '$and': [{ '$ne': { u'card': u'visa' } }, { '$or': [{ '$ge': { u'age': 22 } }, { '$eq': { u'city': u'NY' } }, { '$and': [{ '$ge': { u'age': 18 } }, { '$eq': { u'city': u'London' } }] }] }] })
def test_find_with_condition(self): connection = ConnectionFactory.get_connection( connection_str=CONNECTION_STR, options=CONNECTION_OPTIONS) document_list = [] for i in range(3, 7): document_list.append( connection.new_document( dictionary={ '_id': 'id00%s' % i, 'test_int': i, 'test_str': 'strstr', 'test_dict': { 'test_int': i }, 'test_list': [5, 6], 'test_null': None })) if connection.is_store_exists(store_path='/find-test-store4'): document_store = connection.get_store( store_path='/find-test-store4') else: document_store = connection.create_store( store_path='/find-test-store4') query = OJAIQuery().select(['_id', 'test_int', 'test_str', 'test_dict', 'test_list', 'test_null']) \ .where(OJAIQueryCondition() .and_() .is_('test_int', QueryOp.GREATER_OR_EQUAL, 3) .is_('test_int', QueryOp.LESS_OR_EQUAL, 6).close().close().build()).build() doc_stream = document_store.find(query) index = 0 for doc in doc_stream: self.assertEqual(doc, document_list[index].as_dictionary()) index += 1
def test_nested_condition(self): qc = OJAIQueryCondition().and_() \ .condition_(condition_to_add=OJAIQueryCondition() .or_() .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=22) .is_(field_path='city', op=QueryOp.EQUAL, value='NY').close()) \ .condition_(condition_to_add=OJAIQueryCondition() .and_() .is_(field_path='age', op=QueryOp.GREATER_OR_EQUAL, value=18) .is_(field_path='city', op=QueryOp.EQUAL, value='London').close()) qc.close().build() self.assertEqual( qc.as_dictionary(), { '$and': [{ '$or': [{ '$ge': { u'age': 22 } }, { '$eq': { u'city': u'NY' } }] }, { '$and': [{ '$ge': { u'age': 18 } }, { '$eq': { u'city': u'London' } }] }] })
def test_not_like(self): qc = OJAIQueryCondition().not_like_('card', 'visa').close().build() self.assertEqual(qc.as_dictionary(), {'$notlike': {'card': 'visa'}})
def new_condition(self): return OJAIQueryCondition()
def test_not_exists(self): qc = OJAIQueryCondition().not_exists_('city').close().build() self.assertEqual(qc.as_dictionary(), {'$notexists': 'city'})
def test_query_check_existing_condition(self): qc = OJAIQueryCondition().is_('age', QueryOp.GREATER_OR_EQUAL, 55).is_('age', QueryOp.GREATER_OR_EQUAL, 18) \ .close().build() self.assertEqual(qc.as_dictionary(), {'$ge': {'age': 18}})