Esempio n. 1
0
    def test_multi_search_with_error(self):
        self.client.msearch = MagicMock(
            return_value={
                u'responses': [
                    {
                        u'_shards': {
                            u'failed': 0,
                            u'successful': 64,
                            u'total': 64
                        },
                        u'hits': {
                            u'hits': [],
                            u'max_score': 0.0,
                            u'total': 27802974
                        },
                        u'timed_out': False,
                        u'took': 59
                    },
                    {
                        u'error': u'SearchPhaseExecutionException[Failed to execute phase [query], all shards failed;'
                    }
                ]
            }
        )
        ProductDoc = self.index.product
        sq1 = SearchQuery(doc_cls=ProductDoc, search_type='count', routing=123)
        sq2 = (
            SearchQuery(index=self.cluster['us'], doc_cls=ProductDoc)
            .filter(ProductDoc.status == 0)
            .limit(1)
        )

        self.assertRaises(MultiSearchError, lambda: self.cluster.multi_search([sq1, sq2]))

        results = self.cluster.multi_search([sq1, sq2], raise_on_error=False)

        self.assertIs(results[0], sq1.get_result())
        self.assertIs(results[1], sq2.get_result())
        self.assertEqual(results[0].total, 27802974)
        self.assertEqual(results[0].took, 59)
        self.assertEqual(results[0].timed_out, False)
        self.assertEqual(results[0].max_score, 0.0)
        self.assertEqual(len(results[0].hits), 0)
        self.assertRaisesRegexp(DelayedElasticsearchException, r'^SearchPhaseExecutionException', lambda: results[1].total)
        self.assertRaisesRegexp(DelayedElasticsearchException, r'^SearchPhaseExecutionException', lambda: results[1].hits)
        self.assertRaises(AttributeError, lambda: results[1].unknown_attr)
Esempio n. 2
0
    def test_multi_search_with_error(self):
        self.client.msearch = Mock(
            return_value={
                u'responses': [{
                    u'_shards': {
                        u'failed': 0,
                        u'successful': 64,
                        u'total': 64
                    },
                    u'hits': {
                        u'hits': [],
                        u'max_score': 0.0,
                        u'total': 27802974
                    },
                    u'timed_out': False,
                    u'took': 59
                }, {
                    u'error':
                    u'SearchPhaseExecutionException[Failed to execute phase [query], all shards failed;'
                }]
            })
        ProductDoc = self.index['product']
        sq1 = SearchQuery(doc_cls=ProductDoc, search_type='count', routing=123)
        sq2 = (SearchQuery(
            index=self.cluster['us'],
            doc_cls=ProductDoc).filter(ProductDoc.status == 0).limit(1))

        self.assertRaises(MultiSearchError,
                          lambda: self.cluster.multi_search([sq1, sq2]))

        results = self.cluster.multi_search([sq1, sq2], raise_on_error=False)

        self.assertIs(results[0], sq1.get_result())
        self.assertIs(results[1], sq2.get_result())
        self.assertEqual(results[0].total, 27802974)
        self.assertEqual(results[0].took, 59)
        self.assertEqual(results[0].timed_out, False)
        self.assertEqual(results[0].max_score, 0.0)
        self.assertEqual(len(results[0].hits), 0)
        self.assertTrue(
            results[1].error.startswith('SearchPhaseExecutionException'))
        self.assertIsNone(results[1].total)
        self.assertEqual(results[1].hits, [])
        self.assertRaises(AttributeError, lambda: results[1].unknown_attr)
Esempio n. 3
0
    def test_multi_search(self):
        self.client.msearch = MagicMock(
            return_value={
                u'responses': [
                    {
                        u'_shards': {
                            u'failed': 0,
                            u'successful': 64,
                            u'total': 64
                        },
                        u'hits': {
                            u'hits': [],
                            u'max_score': 0.0,
                            u'total': 27802974
                        },
                        u'timed_out': False,
                        u'took': 59
                    },
                    {
                        u'_shards': {
                            u'failed': 0,
                            u'successful': 16,
                            u'total': 16
                        },
                        u'hits': {
                            u'hits': [
                                {
                                    u'_id': u'56565215',
                                    u'_index': u'ca',
                                    u'_type': u'product',
                                    u'_score': 1.0,
                                    u'_source': {
                                        u'name': u'Gold usb cable',
                                        u'price': {u'local': 92.421, u'unit': 5.67},
                                        u'status': 0
                                    },
                                }
                            ],
                            u'max_score': 1.0,
                            u'total': 272
                        },
                        u'timed_out': False,
                        u'took': 53
                    }
                ]
            }
        )
        ProductDoc = self.index.product
        sq1 = SearchQuery(doc_cls=ProductDoc, search_type='count', routing=123)
        sq2 = (
            SearchQuery(index=self.cluster['us'], doc_cls=ProductDoc)
            .filter(ProductDoc.status == 0)
            .limit(1)
        )
        results = self.cluster.multi_search([sq1, sq2])
        self.client.msearch.assert_called_with(
            body=[
                {'type': 'product', 'search_type': 'count', 'routing': 123},
                {},
                {'index': 'us', 'type': 'product'},
                {'query': {'filtered': {'filter': {'term': {'status': 0}}}}, 'size': 1}
            ]
        )

        self.assertIs(results[0], sq1.get_result())
        self.assertIs(results[1], sq2.get_result())
        self.assertEqual(results[0].total, 27802974)
        self.assertEqual(len(results[0].hits), 0)
        self.assertEqual(results[1].total, 272)
        self.assertEqual(len(results[1].hits), 1)
        doc = results[1].hits[0]
        self.assertEqual(doc._id, '56565215')
        self.assertEqual(doc._index, 'ca')
        self.assertEqual(doc._type, 'product')
        self.assertAlmostEqual(doc._score, 1.0)
        self.assertEqual(doc.name, 'Gold usb cable')
        self.assertAlmostEqual(doc.price.local, 92.421)
        self.assertAlmostEqual(doc.price.unit, 5.67)
        self.assertEqual(doc.status, 0)
Esempio n. 4
0
    def test_multi_search(self):
        self.client.msearch = Mock(
            return_value={
                u'responses': [{
                    u'_shards': {
                        u'failed': 0,
                        u'successful': 64,
                        u'total': 64
                    },
                    u'hits': {
                        u'hits': [],
                        u'max_score': 0.0,
                        u'total': 27802974
                    },
                    u'timed_out': False,
                    u'took': 59
                }, {
                    u'_shards': {
                        u'failed': 0,
                        u'successful': 16,
                        u'total': 16
                    },
                    u'hits': {
                        u'hits': [{
                            u'_id': u'56565215',
                            u'_index': u'ca',
                            u'_type': u'product',
                            u'_score': 1.0,
                            u'_source': {
                                u'name': u'Gold usb cable',
                                u'price': {
                                    u'local': 92.421,
                                    u'unit': 5.67
                                },
                                u'status': 0
                            },
                        }],
                        u'max_score':
                        1.0,
                        u'total':
                        272
                    },
                    u'timed_out': False,
                    u'took': 53
                }]
            })
        ProductDoc = self.index['product']
        sq1 = SearchQuery(doc_cls=ProductDoc, search_type='count', routing=123)
        sq2 = (SearchQuery(
            index=self.cluster['us'],
            doc_cls=ProductDoc).filter(ProductDoc.status == 0).limit(1))
        results = self.cluster.multi_search([sq1, sq2])
        self.client.msearch.assert_called_with(body=[{
            'type': 'product',
            'search_type': 'count',
            'routing': 123
        }, {}, {
            'index': 'us',
            'type': 'product'
        }, {
            'query': {
                'bool': {
                    'filter': {
                        'term': {
                            'status': 0
                        }
                    }
                }
            },
            'size': 1
        }])

        self.assertIs(results[0], sq1.get_result())
        self.assertIs(results[1], sq2.get_result())
        self.assertEqual(results[0].total, 27802974)
        self.assertEqual(len(results[0].hits), 0)
        self.assertEqual(results[1].total, 272)
        self.assertEqual(len(results[1].hits), 1)
        doc = results[1].hits[0]
        self.assertEqual(doc._id, '56565215')
        self.assertEqual(doc._index, 'ca')
        self.assertEqual(doc._type, 'product')
        self.assertAlmostEqual(doc._score, 1.0)
        self.assertEqual(doc.name, 'Gold usb cable')
        self.assertAlmostEqual(doc.price.local, 92.421)
        self.assertAlmostEqual(doc.price.unit, 5.67)
        self.assertEqual(doc.status, 0)