Beispiel #1
0
    def test_build_q_simple_singlefield(self):

        filters_config = {"search_b": ["b_char", "c_text"]}
        params = {"search_b": "one"}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 20)
Beispiel #2
0
    def test_build_q_simple_field(self):

        filters_config = {"search_b": ['b_char']}
        params = {"search_b": "one"}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
Beispiel #3
0
    def test_build_q_singlefield(self):

        filters_config = {"search": {"operator": "__lte", "fields": ["a_int"]}}

        params = {"search": 5}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 60)
Beispiel #4
0
    def test_build_q_ignore(self):
        #TODO: not very informative right now
        #... should be tested in association with a form to ensure that params
        #... are ignored BUT passed to the form

        filters_config = {"search_b": {"ignore": True}}
        params = {"search_b": "one"}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 100)
    def test_build_q_simple_field(self):

        filters_config = {
            "search_b" : ['b_char']
        }
        params  = {
            "search_b" : "one"
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
    def test_build_q_simple_singlefield(self):

        filters_config = {
            "search_b" : ["b_char", "c_text"]
        }
        params  = {
            "search_b" : "one"
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 20)
    def test_build_q_ignore(self):
        #TODO: not very informative right now
        #... should be tested in association with a form to ensure that params
        #... are ignored BUT passed to the form

        filters_config = {
            "search_b" : {"ignore":True}
        }
        params  = {
            "search_b" : "one"
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 100)
    def test_fixed_filters(self):

        filters_config = {
            "search_a" : {
                "fields" : ["a_int"],
                "operator" : "__lt",
                "fixed_filters" : { "b_char" : "one"}
            }
        }
        params  = {
            "search_a" : 5
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
    def test_build_q_singlefield(self):

        filters_config = {
            "search" : {
                "operator" : "__lte",
                "fields" : ["a_int"]
            }
        }

        params  = {
            "search" : 5
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 60)
Beispiel #10
0
    def test_custom_query(self):
        def custom(field, value, params):
            return Q(a_int=value)

        filters_config = {
            "search_a": {
                "custom_query": custom,
                "fields": ["a_int"]
            }
        }

        params = {"search_a": 2}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
Beispiel #11
0
    def test_fixed_filters_callable(self):
        def fixed(params):
            return Q(b_char__in=["one", "two"])

        filters_config = {
            "search_a": {
                "fields": ["a_int"],
                "operator": "__lt",
                "fixed_filters": fixed
            }
        }
        params = {"search_a": 5}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 20)
Beispiel #12
0
    def test_fixed_filters(self):

        filters_config = {
            "search_a": {
                "fields": ["a_int"],
                "operator": "__lt",
                "fixed_filters": {
                    "b_char": "one"
                }
            }
        }
        params = {"search_a": 5}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
    def test_custom_query(self):

        def custom(field, value, params):
            return Q(a_int=value)

        filters_config = {
            "search_a" : {
                "custom_query" : custom,
                "fields" : ["a_int"]
            }
        }

        params  = { "search_a": 2 }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 10)
    def test_fixed_filters_callable(self):
        def fixed(params):
            return Q(b_char__in=["one", "two"])

        filters_config = {
            "search_a" : {
                "fields" : ["a_int"],
                "operator" : "__lt",
                "fixed_filters" : fixed
            }
        }
        params  = {
            "search_a" : 5
        }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 20)
Beispiel #15
0
    def test_build_q_multifield(self):

        filters_config = {
            "search_a": {
                "operator": "__lte",
                "fields": ["a_int"]
            },
            "search_b": {
                "operator": "__in",
                "fields": ["b_char"],
                "multiple": True
            }
        }

        params = {"search_a": 5, "search_b": ["one", "two", "three"]}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 30)
Beispiel #16
0
    def test_custom_query_multi(self):
        def custom(field, value, params):
            return Q(a_int=value)

        filters_config = {
            "search_a": {
                "custom_query": custom,
                "fields": ["a_int"]
            },
            "search_b": {
                "fields": ["b_char", "c_text"],
                "operator": "__iexact"
            }
        }

        params = {"search_a": 2, "search_b": "one"}

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 0)
    def test_custom_query_multi(self):

        def custom(field, value, params):
            return Q(a_int=value)

        filters_config = {
            "search_a" : {
                "custom_query" : custom,
                "fields" : ["a_int"]
            },
            "search_b" : {
                "fields" : ["b_char", "c_text"],
                "operator" : "__iexact"
            }
        }

        params  = { "search_a": 2, "search_b" : "one" }

        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 0)
    def test_build_q_multifield(self):

        filters_config = {
            "search_a" : {
                "operator" : "__lte",
                "fields" : ["a_int"]
            },
            "search_b" : {
                "operator" : "__in",
                "fields" : ["b_char"],
                "multiple" : True
            }
        }

        params  = {
            "search_a" : 5,
            "search_b" : ["one", "two", "three"]
        }


        q = build_q(filters_config, params)
        objs = self.test_model.objects.filter(q)
        self.assertEquals(objs.count(), 30)
Beispiel #19
0
 def build_q(cls, params, request=None):
     if not params.get('q'):
         return Q(pk=None)
     return build_q(cls.get_search_fields(), params, request)