In Operator

setup.py

@@ -1,6 +1,7 @@
 import os
 from setuptools import setup
 
+
 def read(*paths):
     """Build a file path from *paths* and return the contents."""
     with open(os.path.join(*paths), 'r') as f:
@@ -17,14 +18,17 @@ def read(*paths):
     packages=['sqlalchemy_elasticquery'],
     include_package_data=True,
     install_requires=[
+        'Flask>=0.10',
         'SQLAlchemy>=0.7.8',
     ],
     classifiers=[
         'Development Status :: 4 - Beta',
         'Environment :: Plugins',
+        'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
         'Topic :: Database'
+        'Topic :: Software Development :: Libraries :: Python Modules'
     ]
 )

sqlalchemy_elasticquery/elastic_query.py

@@ -79,8 +79,11 @@ def __init__(self, model, query, session=None, enabled_fields=None):
 
     def search(self):
         """ This is the most important method """
-        # TODO: verify format and emit expetion
-        filters = json.loads(self.query)
+        try:
+            filters = json.loads(self.query)
+        except ValueError:
+            return False
+
         result = self.model_query
         if 'filter'in filters.keys():
             result = self.parse_filter(filters['filter'])
@@ -120,14 +123,15 @@ def parse_field(self, field, field_value):
             value = field_value
         return field, operator, value
 
-    def verify_operator(self, operator):
+    @staticmethod
+    def verify_operator(operator):
         """ Verify if the operator is valid """
         try:
             if hasattr(OPERATORS[operator], '__call__'):
                 return True
             else:
                 return False
-        except:
+        except ValueError:
             return False
 
     def is_field_allowed(self, field):

test/test.py

@@ -4,11 +4,11 @@
 from flask.ext.sqlalchemy import SQLAlchemy
 from sqlalchemy.orm import sessionmaker, relationship
 from sqlalchemy_elasticquery import elastic_query
-from sqlalchemy import and_, or_
 from flask import Flask
 
 Base = declarative_base()
 
+
 class City(Base):
     __tablename__ = 'city'
 
@@ -18,6 +18,7 @@ class City(Base):
     def __repr__(self):
         return str(self.id)
 
+
 class User(Base):
     __tablename__ = 'users'
 
@@ -31,6 +32,7 @@ class User(Base):
     def __repr__(self):
         return str(self.id)
 
+
 class TestCase(unittest.TestCase):
 
     def setUp(self):
@@ -67,27 +69,38 @@ def test_simple_query(self):
 
     def test_and_operator(self):
         """ test and operator """
-        query_string = '{"filter" : {"and" : {"name" : {"like" : "%Jho%"}, "lastname" : "Galt", "uid" : {"like" : "%1957%"} } } }'
+        query_string = \
+            '{"filter" : {"and" : {"name" : {"like" : "%Jho%"}, "lastname" : "Galt", "uid" : {"like" : "%1957%"} } } }'
         assert(elastic_query(User, query_string, session).count() == 1)
 
     def test_or_operator(self):
         """ test or operator """
-        query_string = '{"filter" : {"or" : { "name" : "Jobs", "lastname" : "Man", "uid" : "19571957" } } }'
+        query_string = \
+            '{"filter" : {"or" : { "name" : "Jobs", "lastname" : "Man", "uid" : "19571957" } } }'
         assert(elastic_query(User, query_string, session).count() == 2)
 
     def test_or_and_operator(self):
         """ test or and operator """
-        query_string = '{"filter" : {"or" : { "name" : "Jhon", "lastname" : "Galt" }, "and" : { "uid" : "19571957" } } }'
+        query_string = \
+            '{"filter" : {"or" : { "name" : "Jhon", "lastname" : "Galt" }, "and" : { "uid" : "19571957" } } }'
         assert(elastic_query(User, query_string, session).count() == 1)
 
     def test_sorting(self):
         """ test operator levels """
-        query_string = '{"filter" : {"or" : { "name" : "Jhon", "lastname" : "Man" } }, "sort": { "name" : "asc" } }'
+        query_string = \
+            '{"filter" : {"or" : { "name" : "Jhon", "lastname" : "Man" } }, "sort": { "name" : "asc" } }'
         results = elastic_query(User, query_string, session).all()
         assert(results[0].name == 'Iron')
 
+    def test_in_operator(self):
+        """ test operator in """
+        query_string = '{"filter" : {"name" : {"in" : ["Jhon", "Peter", "Iron"] } } }'
+        assert(elastic_query(User, query_string, session).count() == 2)
+
+        query_string = '{"filter" : {"name" : {"in" :["Jhon", "Peter", "Iron"]}, "lastname" : "Galt" } }'
+        assert(elastic_query(User, query_string, session).count() == 1)
+
     def test_flask(self):
-        #Flask app
         app = Flask(__name__)
         db = SQLAlchemy(app)
         app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
@@ -126,7 +139,8 @@ def test_allow_fields_option(self):
 
     def test_search_for_levels(self):
         """ test search for levels """
-        query_string = '{"filter" : {"or" : { "city.name" : "New York", "lastname" : "Man" } }, "sort": { "name" : "asc" } }'
+        query_string = \
+            '{"filter" : {"or" : { "city.name" : "New York", "lastname" : "Man" } }, "sort": { "name" : "asc" } }'
         results = elastic_query(User, query_string, session).all()
         assert(results[0].name == 'Iron')