QueryBuilderTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	test_if_there_is_a_query_param_as_list_an_or_filter_will_be_added()	0	6	1
A	test_a_filtered_query_string_with_filters_can_be_built()	0	8	1
A	test_if_there_is_a_query_param_named_concept_filter_can_be_added()	0	5	1
A	test_if_there_are_query_params_named_concept_filters_can_be_added()	0	4	1
A	test_if_there_are_no_query_params_no_concept_filters_can_be_added()	0	4	1
A	test_concept_filters_will_not_be_added_if_query_param_not_available()	0	4	1
A	setUp()	0	5	1
A	test_if_there_is_a_query_param_named_query_a_query_string_can_be_build_on_all_fields()	0	5	1
A	test_if_there_are_no_query_params_a_match_all_query_can_be_built()	0	4	1
A	test_if_there_are_query_params_concept_filters_can_be_added()	0	6	1

import unittest

from oe_utils.search.query_builder import QueryBuilder


class QueryBuilderTest(unittest.TestCase):
    def setUp(self):
        self.query_builder = QueryBuilder({
            'param1': 'dummy',
            'param2': 'dummy2',
            'list-param': ['list-item1', 'list-item2']
        })

    def test_if_there_are_no_query_params_a_match_all_query_can_be_built(self):
        query = QueryBuilder().build()

        self.assertIn('match_all', query)

    def test_if_there_is_a_query_param_named_query_a_query_string_can_be_build_on_all_fields(self):
        query = QueryBuilder({'query': 'dummy'}).build()

        self.assertEquals(query['query_string']['query'], 'dummy')
        self.assertEquals(query['query_string']['default_field'], '_all')

    def test_if_there_are_no_query_params_no_concept_filters_can_be_added(self):
        query_builder = QueryBuilder()

        self.assertRaises(AttributeError, query_builder.add_concept_filter, '')

    def test_if_there_are_query_params_concept_filters_can_be_added(self):
        self.query_builder.add_concept_filters(['param1', 'param2'])

        self.assertEquals(len(self.query_builder.filters), 2)
        self.assertEquals(self.query_builder.filters[0]['term']['param1'], 'dummy')
        self.assertEquals(self.query_builder.filters[1]['term']['param2'], 'dummy2')

    def test_concept_filters_will_not_be_added_if_query_param_not_available(self):
        self.query_builder.add_concept_filters(['param_not_as_query_param'])

        self.assertEquals(len(self.query_builder.filters), 0)

    def test_if_there_are_query_params_named_concept_filters_can_be_added(self):
        self.query_builder.add_named_concept_filters({'param1': 'search_term1', 'param2': 'search_term2'})

        self.assertEquals(len(self.query_builder.filters), 2)

    def test_if_there_is_a_query_param_named_concept_filter_can_be_added(self):
        self.query_builder.add_named_concept_filters({'param1': 'search_term1'})

        self.assertEquals(len(self.query_builder.filters), 1)
        self.assertEquals(self.query_builder.filters[0]['term']['search_term1'], 'dummy')

    def test_if_there_is_a_query_param_as_list_an_or_filter_will_be_added(self):
        self.query_builder.add_concept_filter('list-param')

        self.assertEquals(len(self.query_builder.filters), 1)
        self.assertEquals(self.query_builder.filters[0]['or'][0]['term']['list-param'], 'list-item1')
        self.assertEquals(self.query_builder.filters[0]['or'][1]['term']['list-param'], 'list-item2')

    def test_a_filtered_query_string_with_filters_can_be_built(self):
        self.query_builder.filters = 'dummy-filters'
        self.query_builder.query = 'dummy-query'

        query = self.query_builder.build()

        self.assertEquals(query['filtered']['filter']['and'], 'dummy-filters')
        self.assertEquals(query['filtered']['query'], 'dummy-query')