← Back to branch summary

~jcsackett/charmworld/bac-tag-constraints

« back to all changes in this revision

Viewing changes to charmworld/tests/test_search.py

[r=benji][bug=][author=sinzui] Update IndexClient.api_search to include the doctype of the found document.

Show diffs side-by-side

added added

removed removed

Lines of Context:
charmworld/tests/test_search.py
363
363
        return one, two, bundle
364
364
 
365
365
    def test_api_search_all(self):
366
 
        """With no parameters, all charms are returned."""
 
366
        # With no parameters, all charms and bundles are returned.
367
367
        one, two, bundle = self.get_charm_bundle_test_data()
368
368
        result = self.get_charms_and_bundles(doctype=None)
369
 
        result = sorted(result, key=lambda x: x['name'])
370
369
        self.assertEqual(3, len(result))
371
370
        one_url = make_store_url(1, get_address(one, short=True))
372
371
        self.assertEqual(one, result[0])
380
379
        """With no parameters, all charms are returned."""
381
380
        one, two, bundle = self.get_charm_bundle_test_data()
382
381
        result = self.get_charms_and_bundles(doctype=CHARM)
383
 
        result = sorted(result, key=lambda x: x['name'])
384
382
        self.assertEqual(2, len(result))
385
383
        self.assertEqual(one, result[0])
386
384
        self.assertEqual(two, result[1])
390
388
        """Passing doctype of 'bundles' retrieves only bundles."""
391
389
        one, two, bundle = self.get_charm_bundle_test_data()
392
390
        result = self.get_charms_and_bundles(doctype=BUNDLE)
393
 
        result = sorted(result, key=lambda x: x['name'])
394
391
        self.assertEqual(1, len(result))
395
392
        self.assertEqual(bundle, result[0])
396
393
 
404
401
        for field in charm_exact_fields:
405
402
            differing_charm[field] = 'foo'
406
403
        self.index_client.index_charm(differing_charm)
407
 
        ids = [charm['_id'] for charm in self.index_client.api_search('foo',
408
 
               autocomplete=True)]
 
404
        result = self.index_client.api_search('foo', autocomplete=True)
 
405
        ids = [r['data']['_id'] for r in result]
409
406
        self.assertEqual([matching_charm['_id']], ids)
410
407
 
411
408
    def test_autocomplete_matches_on_prefix(self):
412
409
        charm1 = self.makeCharm(name='foo')
413
410
        charm2 = self.makeCharm(name='foobar')
414
411
        self.makeCharm(name='barfoo')
415
 
        ids = [charm['_id'] for charm in self.index_client.api_search('foo',
416
 
               autocomplete=True)]
 
412
        result = self.index_client.api_search('foo', autocomplete=True)
 
413
        ids = [r['data']['_id'] for r in result]
417
414
        self.assertItemsEqual([charm1['_id'], charm2['_id']], ids)
418
415
 
419
416
    def get_charms_and_bundles(self, text='', type_=None, doctype=CHARM,
421
418
        filters = dict((key, [value]) for key, value in kwargs.items())
422
419
        if type_ is not None and isinstance(type_, basestring):
423
420
            type_ = [type_]
424
 
        return self.index_client.api_search(
 
421
        result = self.index_client.api_search(
425
422
            text, filters, type_, doctype=doctype)
 
423
        charms_and_bundles = [r['data'] for r in result]
 
424
        return sorted(charms_and_bundles, key=lambda x: x['name'])
426
425
 
427
426
    def _test_filter(self, filter_str, make_charm=None):
428
427
        if make_charm is None:
484
483
        'community' otherwise.  'environment' causes no charms
485
484
        to be returned.
486
485
        """
487
 
        self.makeCharm(owner='alice', promulgated=True)
488
 
        self.makeCharm(owner='steve')
 
486
        self.makeCharm(owner='alice', name='ant', promulgated=True)
 
487
        self.makeCharm(owner='steve', name='bat')
489
488
        result = self.get_charms_and_bundles(type_='community')
490
489
        self.assertEqual(['steve'], [charm['owner'] for charm in result])
491
490
        result = self.get_charms_and_bundles(type_='approved')
535
534
        with self.assertRaises(NegativeLimit):
536
535
            result = self.index_client.api_search('', {}, None, -1)
537
536
 
538
 
    def test_api_search_charm_with_store_error(self):
 
537
    def test_api_search_with_store_error(self):
539
538
        """api_search() does not return charms withs errors by default."""
540
539
        self.makeCharm(name='evil-charm', charm_error=True)
541
540
        self.makeCharm(name='good-charm')
542
541
        self.makeBundle(name='great-bundle')
543
542
        result = self.index_client.api_search('', {}, None, doctype=None)
544
543
        self.assertEqual(2, len(result))
545
 
        names = set(charm['name'] for charm in result)
 
544
        names = set(charm['data']['name'] for charm in result)
546
545
        self.assertEqual(set(('good-charm', 'great-bundle')), names)
547
546
        # Charms with error are included in the search result
548
547
        # if the parameter valid_only is set to False.  Bundles are
550
549
        result = self.index_client.api_search(
551
550
            '', {}, None, valid_only=False, doctype=None)
552
551
        self.assertEqual(3, len(result))
553
 
        names = set(charm['name'] for charm in result)
 
552
        names = set(charm['data']['name'] for charm in result)
554
553
        self.assertEqual(
555
554
            set(('good-charm', 'evil-charm', 'great-bundle')), names)
556
555
 
557
 
    def test_search_charm_with_store_error(self):
 
556
    def test_search_with_store_error(self):
558
557
        """search() does not return charms withs errors by default."""
559
558
        self.makeCharm(name='evil-charm', owner='foo', charm_error=True)
560
559
        self.makeCharm(name='good-charm', owner='foo')
590
589
        charm['error'] = {'error': 'error text'}
591
590
        self.index_client.index_charm(charm)
592
591
        result = self.index_client.api_search(charm['name'])
593
 
        self.assertEqual([charm], result)
 
592
        self.assertEqual([charm], [r['data'] for r in result])
594
593
 
595
594
    def test_search_charm_sort_most_downloaded(self):
596
595
        """Specifying 'downloaded' sorts results appropriately."""
599
598
        self.makeCharm(name='popular3', downloads=2)
600
599
        order132 = ['popular1', 'popular3', 'popular2']
601
600
        result = self.index_client.api_search()
602
 
        self.assertNotEqual(order132, [r['name'] for r in result])
 
601
        self.assertNotEqual(order132, [r['data']['name'] for r in result])
603
602
        result = self.index_client.api_search(sort='downloaded')
604
 
        self.assertEqual(order132, [r['name'] for r in result])
 
603
        self.assertEqual(order132, [r['data']['name'] for r in result])
605
604
 
606
605
    def test_search_charm_sort_newest(self):
607
606
        """Specifying 'new' sorts results appropriately."""
610
609
        self.makeCharm(name='new3', date_created=datetime(2013, 1, 1))
611
610
        order123 = ['new1', 'new2', 'new3']
612
611
        result = self.index_client.api_search()
613
 
        self.assertNotEqual(order123, [r['name'] for r in result])
 
612
        self.assertNotEqual(order123, [r['data']['name'] for r in result])
614
613
        result = self.index_client.api_search(sort='new')
615
 
        self.assertEqual(order123, [r['name'] for r in result])
 
614
        self.assertEqual(order123, [r['data']['name'] for r in result])
616
615
 
617
616
    def test_search_unknown_sort(self):
618
617
        """Specifying an unknown sort raises an exception."""
904
903
            owner='a', name='b', basket='c/2')
905
904
        self.index_client.index_bundle(bundle_data)
906
905
        self.index_client.index_bundle(bundle_data_2)
907
 
        self.assertEqual(['~a/c/2/b'], [b['_id'] for b in
 
906
        self.assertEqual(['~a/c/2/b'], [b['data']['_id'] for b in
908
907
                         self.index_client.api_search(doctype=None)])
909
908
 
910
909