def test_query_related_field(self):
        """Test for making a query with respect to a related field."""
        # add a computer to person 1
        computer = self.Computer(name=u'turing', vendor=u'Dell')
        p1 = self.session.query(self.Person).filter_by(id=1).first()
        p1.computers.append(computer)
        self.session.commit()

        d = {
            'filters': [{
                'name': 'computers__name',
                'val': u'turing',
                'op': 'any'
            }]
        }
        query = create_query(self.session, self.Person, d)
        assert query.count() == 1
        assert query.one().computers[0].name == 'turing'

        d = {
            'filters': [{
                'name': 'age',
                'op': 'lte',
                'field': 'other'
            }],
            'order_by': [{
                'field': 'other'
            }]
        }
        query = create_query(self.session, self.Person, d)
        assert query.count() == 2
        results = query.all()
        assert results[0].other == 10
        assert results[1].other == 19
Example #2
0
    def test_dict_same_as_search_params(self):
        """Tests that creating a query using a dictionary results in the same
        query as creating one using a
        :class:`flask_restless.search.SearchParameters` object.

        """
        d = {"filters": [{"name": "name", "val": u"%y%", "op": "like"}]}
        s = SearchParameters.from_dictionary(d)
        query_d = create_query(self.session, self.Person, d)
        query_s = create_query(self.session, self.Person, s)
        self.assertEqual(query_d.all(), query_s.all())
Example #3
0
    def test_dict_same_as_search_params(self):
        """Tests that creating a query using a dictionary results in the same
        query as creating one using a
        :class:`flask_restless.search.SearchParameters` object.

        """
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        s = SearchParameters.from_dictionary(d)
        query_d = create_query(self.session, self.Person, d)
        query_s = create_query(self.session, self.Person, s)
        self.assertEqual(query_d.all(), query_s.all())
    def test_dict_same_as_search_params(self):
        """Tests that creating a query using a dictionary results in the same
        query as creating one using a
        :class:`flask_restless.search.SearchParameters` object.

        """
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        s = SearchParameters.from_dictionary(d)
        query_d = create_query(self.session, self.Person, d)
        query_s = create_query(self.session, self.Person, s)
        assert query_d.all() == query_s.all()
    def test_order_by_and_filter_on_the_same_relation(self):

        # Given
        computer_for_mary = self.Computer(name=u'1st', vendor=u'vendor')
        mary = self.session.query(self.Person).filter_by(name=u'Mary').first()
        mary.computers.append(computer_for_mary)
        computer_for_lucy = self.Computer(name=u'2nd', vendor=u'vendor')
        lucy = self.session.query(self.Person).filter_by(name=u'Lucy').first()
        lucy.computers.append(computer_for_lucy)
        self.session.commit()

        # When
        d = {
            'filters': [
                {
                    'name': 'owner',
                    'op': 'has',
                    'val': {
                        'name': 'name',
                        'op': 'like',
                        'val': '%y'
                    }
                }
            ],
            'order_by': [{'field': 'owner__name', 'direction': 'asc'}]
        }
        query = create_query(self.session, self.Computer, d)

        # Then
        assert query.count() == 2
        results = query.all()
        assert results[0].owner.name == u'Lucy'
        assert results[1].owner.name == u'Mary'
    def test_order_by_two_different_fields_of_the_same_relation(self):

        # Given
        computer_for_mary = self.Computer(name=u'1st', vendor=u'vendor')
        mary = self.session.query(self.Person).filter_by(name=u'Mary').first()
        mary.computers.append(computer_for_mary)
        computer_for_lucy = self.Computer(name=u'2nd', vendor=u'vendor')
        lucy = self.session.query(self.Person).filter_by(name=u'Lucy').first()
        lucy.computers.append(computer_for_lucy)
        self.session.commit()

        # When
        d = {
            'order_by': [
                {'field': 'owner__age', 'direction': 'asc'},
                {'field': 'owner__name', 'direction': 'asc'},

            ]
        }
        query = create_query(self.session, self.Computer, d)

        # Then
        assert query.count() == 2
        results = query.all()
        assert results[0].owner.name == u'Mary'
        assert results[1].owner.name == u'Lucy'
    def test_order_by_two_different_fields_of_the_same_relation(self):

        # Given
        computer_for_mary = self.Computer(name=u'1st', vendor=u'vendor')
        mary = self.session.query(self.Person).filter_by(name=u'Mary').first()
        mary.computers.append(computer_for_mary)
        computer_for_lucy = self.Computer(name=u'2nd', vendor=u'vendor')
        lucy = self.session.query(self.Person).filter_by(name=u'Lucy').first()
        lucy.computers.append(computer_for_lucy)
        self.session.commit()

        # When
        d = {
            'order_by': [
                {
                    'field': 'owner__age',
                    'direction': 'asc'
                },
                {
                    'field': 'owner__name',
                    'direction': 'asc'
                },
            ]
        }
        query = create_query(self.session, self.Computer, d)

        # Then
        assert query.count() == 2
        results = query.all()
        assert results[0].owner.name == u'Mary'
        assert results[1].owner.name == u'Lucy'
    def test_order_by_and_filter_on_the_same_relation(self):

        # Given
        computer_for_mary = self.Computer(name=u'1st', vendor=u'vendor')
        mary = self.session.query(self.Person).filter_by(name=u'Mary').first()
        mary.computers.append(computer_for_mary)
        computer_for_lucy = self.Computer(name=u'2nd', vendor=u'vendor')
        lucy = self.session.query(self.Person).filter_by(name=u'Lucy').first()
        lucy.computers.append(computer_for_lucy)
        self.session.commit()

        # When
        d = {
            'filters': [{
                'name': 'owner',
                'op': 'has',
                'val': {
                    'name': 'name',
                    'op': 'like',
                    'val': '%y'
                }
            }],
            'order_by': [{
                'field': 'owner__name',
                'direction': 'asc'
            }]
        }
        query = create_query(self.session, self.Computer, d)

        # Then
        assert query.count() == 2
        results = query.all()
        assert results[0].owner.name == u'Lucy'
        assert results[1].owner.name == u'Mary'
Example #9
0
    def test_query_related_field(self):
        """Test for making a query with respect to a related field."""
        # add a computer to person 1
        computer = self.Computer(name=u"turing", vendor=u"Dell")
        p1 = self.session.query(self.Person).filter_by(id=1).first()
        p1.computers.append(computer)
        self.session.commit()

        d = {"filters": [{"name": "computers__name", "val": u"turing", "op": "any"}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 1)
        self.assertEqual(query.one().computers[0].name, "turing")

        d = {"filters": [{"name": "age", "op": "lte", "field": "other"}], "order_by": [{"field": "other"}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 2)
        results = query.all()
        self.assertEqual(results[0].other, 10)
        self.assertEqual(results[1].other, 19)
Example #10
0
    def test_query_related_field(self):
        """Test for making a query with respect to a related field."""
        # add a computer to person 1
        computer = self.Computer(name=u'turing', vendor=u'Dell')
        p1 = self.session.query(self.Person).filter_by(id=1).first()
        p1.computers.append(computer)
        self.session.commit()

        d = {'filters': [{'name': 'computers__name', 'val': u'turing',
                          'op': 'any'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 1)
        self.assertEqual(query.one().computers[0].name, 'turing')

        d = {'filters': [{'name': 'age', 'op': 'lte', 'field': 'other'}],
            'order_by': [{'field': 'other'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 2)
        results = query.all()
        self.assertEqual(results[0].other, 10)
        self.assertEqual(results[1].other, 19)
    def test_basic_query(self):
        """Tests for basic query correctness."""
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 3  # Mary, Lucy and Katy

        d = {'filters': [{'name': 'name', 'val': u'Lincoln', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 1
        assert query.one().name == 'Lincoln'

        d = {'filters': [{'name': 'name', 'val': u'Bogus', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 0

        d = {'order_by': [{'field': 'age', 'direction': 'asc'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        assert ages == [7, 19, 23, 25, 28]

        d = {'order_by': [{'field': 'other', 'direction': 'asc'}],
             'group_by': [{'field': 'other'}]}
        query = create_query(self.session, self.Person, d)
        data = [p.other for p in query]
        assert data == [10.0, 19.0, 20.0, 22.0]

        d = {'filters': [{'name': 'age', 'val': [7, 28], 'op': 'in'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        assert ages == [7, 28]
Example #12
0
    def test_basic_query(self):
        """Tests for basic query correctness."""
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 3)  # Mary, Lucy and Katy

        d = {'filters': [{'name': 'name', 'val': u'Lincoln', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 1)
        self.assertEqual(query.one().name, 'Lincoln')

        d = {'filters': [{'name': 'name', 'val': u'Bogus', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 0)

        d = {'order_by': [{'field': 'age', 'direction': 'asc'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 19, 23, 25, 28])

        d = {'filters': [{'name': 'age', 'val': [7, 28], 'op': 'in'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 28])
Example #13
0
    def test_basic_query(self):
        """Tests for basic query correctness."""
        d = {"filters": [{"name": "name", "val": u"%y%", "op": "like"}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 3)  # Mary, Lucy and Katy

        d = {"filters": [{"name": "name", "val": u"Lincoln", "op": "equals"}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 1)
        self.assertEqual(query.one().name, "Lincoln")

        d = {"filters": [{"name": "name", "val": u"Bogus", "op": "equals"}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 0)

        d = {"order_by": [{"field": "age", "direction": "asc"}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 19, 23, 25, 28])

        d = {"filters": [{"name": "age", "val": [7, 28], "op": "in"}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 28])
Example #14
0
    def test_basic_query(self):
        """Tests for basic query correctness."""
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 3)  # Mary, Lucy and Katy

        d = {'filters': [{'name': 'name', 'val': u'Lincoln', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 1)
        self.assertEqual(query.one().name, 'Lincoln')

        d = {'filters': [{'name': 'name', 'val': u'Bogus', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        self.assertEqual(query.count(), 0)

        d = {'order_by': [{'field': 'age', 'direction': 'asc'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 19, 23, 25, 28])

        d = {'filters': [{'name': 'age', 'val': [7, 28], 'op': 'in'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        self.assertEqual(ages, [7, 28])
Example #15
0
    def test_basic_query(self):
        """Tests for basic query correctness."""
        d = {'filters': [{'name': 'name', 'val': u'%y%', 'op': 'like'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 3  # Mary, Lucy and Katy

        d = {'filters': [{'name': 'name', 'val': u'Lincoln', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 1
        assert query.one().name == 'Lincoln'

        d = {'filters': [{'name': 'name', 'val': u'Bogus', 'op': 'equals'}]}
        query = create_query(self.session, self.Person, d)
        assert query.count() == 0

        d = {'order_by': [{'field': 'age', 'direction': 'asc'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        assert ages, [7, 19, 23, 25 == 28]

        d = {'filters': [{'name': 'age', 'val': [7, 28], 'op': 'in'}]}
        query = create_query(self.session, self.Person, d)
        ages = [p.age for p in query]
        assert ages, [7 == 28]
Example #16
0
    def model_query(model, search_params):
        '''
        模型复杂查询

        :param model:
            实例模型,比如Article, Category, Tag, etc.
        :param search_params:
            参数字典,为dict类型,参照flask-restless文档

        特别注意:使用这个方法进行查询,模型`__mapper_args__`的
        `order_by`定义将会失效,在模板中使用时需要特别注意。

        详细内容请参照Flask-Restless的文档
        '''
        # `is_single` is True when 'single' is a key in ``search_params`` and its
        # corresponding value is anything except those values which evaluate to
        # False (False, 0, the empty string, the empty list, etc.).
        is_single = search_params.get('single')
        query = create_query(db.session, model, search_params)
        if is_single:
            # may raise NoResultFound or MultipleResultsFound
            return query.one()
        return query.all()
Example #17
0
    def model_query(model, search_params):
        '''
        模型复杂查询

        :param model:
            实例模型,比如Article, Category, Tag, etc.
        :param search_params:
            参数字典,为dict类型,参照flask-restless文档

        特别注意:使用这个方法进行查询,模型`__mapper_args__`的
        `order_by`定义将会失效,在模板中使用时需要特别注意。

        详细内容请参照Flask-Restless的文档
        '''
        # `is_single` is True when 'single' is a key in ``search_params`` and its
        # corresponding value is anything except those values which evaluate to
        # False (False, 0, the empty string, the empty list, etc.).
        is_single = search_params.get('single')
        query = create_query(db.session, model, search_params)
        if is_single:
            # may raise NoResultFound or MultipleResultsFound
            return query.one()
        return query.all()
Example #18
0
 def test_empty_search(self):
     """Tests that a query with no search parameters returns everything."""
     query = create_query(self.session, self.Person, {})
     self.assertEqual(query.all(), self.people)
Example #19
0
 def test_empty_search(self):
     """Tests that a query with no search parameters returns everything."""
     query = create_query(self.session, self.Person, {})
     assert query.all() == self.people