← Back to branch summary

~jcsackett/charmworld/bac-tag-constraints

« back to all changes in this revision

Viewing changes to charmworld/tests/test_search.py

  • Committer: Tarmac
  • Author(s): Brad Crittenden
  • Date: 2013-08-01 20:59:27 UTC
  • mfrom: (325.1.9 bundle-search)
  • Revision ID: tarmac-20130801205927-lcbxxxb2bba92akt
[r=abentley][bug=][author=bac] Provide support for bundles in searching. The display of search results in the web app still only shows charms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
charmworld/tests/test_search.py
17
17
    make_store_url,
18
18
)
19
19
from charmworld.models import (
 
20
    Bundle,
20
21
    Charm,
21
22
)
22
23
from charmworld.search import (
106
107
        self.index_client.index_charm(charm)
107
108
        return charm
108
109
 
 
110
    def makeBundle(self, *args, **kwargs):
 
111
        bundle = factory.get_bundle_data(*args, **kwargs)
 
112
        bundle['_id'] = Bundle(bundle).id
 
113
        self.index_client.index_bundle(bundle)
 
114
        return bundle
 
115
 
109
116
    def test_search(self):
110
 
        result_keys = ['results', 'search_time', 'charm_total', 'matches',
 
117
        result_keys = ['results', 'search_time', 'result_total', 'matches',
111
118
                       'matches_human_readable_estimate']
112
119
        client = self.index_client
113
120
        foo_charm = Charm(self.makeCharm())
114
121
        results = client.search('foo')
115
122
        self.assertItemsEqual(result_keys, results.keys())
116
 
        self.assertEqual([], results['results'])
117
 
        results = client.search(foo_charm.name)['results']
 
123
        self.assertEqual([], results['results']['charm'])
 
124
        results = client.search(foo_charm.name)['results']['charm']
118
125
        self.assertEqual(1, len(results))
119
126
        self.assertEqual(foo_charm, results[0]['data'])
120
127
        # The absolute value of weight is not defined, so we just ensure
121
128
        # it's present.
122
129
        self.assertItemsEqual(['data', 'weight'], results[0].keys())
123
130
 
 
131
    def test_search_bundle(self):
 
132
        bundle = Bundle(self.makeBundle())
 
133
        client = self.index_client
 
134
        results = client.search(bundle.name)['results']['bundle']
 
135
        self.assertEqual(1, len(results))
 
136
        self.assertEqual(bundle, results[0]['data'])
 
137
 
 
138
    def test_search_charms_and_bundles_same_name(self):
 
139
        charm = Charm(self.makeCharm(name='mozilla'))
 
140
        bundle = Bundle(self.makeBundle(name='mozilla'))
 
141
        client = self.index_client
 
142
        search_results = client.search('mozilla')
 
143
        results = search_results['results']
 
144
        self.assertEqual(2, len(results))
 
145
        self.assertEqual(2, search_results['result_total'])
 
146
        self.assertEqual(2, search_results['matches'])
 
147
        self.assertEqual(1, len(results['charm']))
 
148
        self.assertEqual(1, len(results['bundle']))
 
149
        self.assertEqual(charm, results['charm'][0]['data'])
 
150
        self.assertEqual(bundle, results['bundle'][0]['data'])
 
151
 
 
152
    def test_search_charms_and_bundles_description(self):
 
153
        charm = Charm(self.makeCharm(description='a mozilla charm'))
 
154
        bundle = Bundle(self.makeBundle(description='a mozilla bundle'))
 
155
        client = self.index_client
 
156
        search_results = client.search('mozilla')
 
157
        results = search_results['results']
 
158
        self.assertEqual(2, len(results))
 
159
        self.assertEqual(2, search_results['result_total'])
 
160
        self.assertEqual(2, search_results['matches'])
 
161
        self.assertEqual(1, len(results['charm']))
 
162
        self.assertEqual(1, len(results['bundle']))
 
163
        self.assertEqual(charm, results['charm'][0]['data'])
 
164
        self.assertEqual(bundle, results['bundle'][0]['data'])
 
165
 
124
166
    def test_search_not_ready(self):
125
167
 
126
168
        class FakeElasticSearch:
146
188
 
147
189
    def search_ids(self, terms):
148
190
        client = self.index_client
149
 
        return [hit['data']._id for hit in client.search(terms)['results']]
 
191
        hits = client.search(terms)['results']['charm']
 
192
        return [hit['data']._id for hit in hits]
150
193
 
151
194
    def test_search_matches_on_search_terms(self):
152
195
        fields = free_text_fields.keys() + exact_fields
216
259
        charm['_id'] = unofficial_id
217
260
        charm['store_url'] = get_address(charm, short=False)
218
261
        client.index_charm(charm)
219
 
        results = client.search('terminal')['results']
 
262
        results = client.search('terminal')['results']['charm']
220
263
        by_id = dict((result['data']._id, result) for result in results)
221
264
        self.assertAlmostEqual(by_id[official_id]['weight'],
222
265
                               by_id[unofficial_id]['weight'] * 10)
231
274
        charm['owner'] = 'jrandom'
232
275
        charm['_id'] = jrandom_id
233
276
        client.index_charm(charm)
234
 
        results = client.search('terminal')['results']
 
277
        results = client.search('terminal')['results']['charm']
235
278
        by_id = dict((result['data']._id, result) for result in results)
236
279
        self.assertAlmostEqual(by_id[charmers_id]['weight'],
237
280
                               by_id[jrandom_id]['weight'])
271
314
                             provides=provides2,
272
315
                             requires=requires2, options=options2,
273
316
                             files=files2, subordinate=True)
274
 
        result = self.get_charms()
275
 
        self.assertEqual(2, len(result))
 
317
        bundle = self.makeBundle(name='name3')
 
318
        result = self.get_charms_and_bundles()
 
319
        result = sorted(result, key=lambda x: x['name'])
 
320
        self.assertEqual(3, len(result))
276
321
        one_url = make_store_url(1, get_address(one, short=True))
277
322
        self.assertEqual(one, result[0])
278
323
        two_url = make_store_url(1, get_address(two, short=False))
279
324
        self.assertEqual(two, result[1])
280
325
        self.assertNotEqual(one['_id'], two['_id'])
281
326
        self.assertNotEqual(one_url, two_url)
 
327
        self.assertEqual(bundle, result[2])
282
328
 
283
329
    def test_autocomplete_matches_on_names(self):
284
330
        matching_charm = self.makeCharm(name='foo')
302
348
               autocomplete=True)]
303
349
        self.assertItemsEqual([charm1['_id'], charm2['_id']], ids)
304
350
 
305
 
    def get_charms(self, text='', type_=None, *args, **kwargs):
 
351
    def get_charms_and_bundles(self, text='', type_=None, kind=CHARM,
 
352
                               *args, **kwargs):
306
353
        filters = dict((key, [value]) for key, value in kwargs.items())
307
354
        if type_ is not None and isinstance(type_, basestring):
308
355
            type_ = [type_]
323
370
        self.index_client.index_charm(three)
324
371
        four = make_charm('different-again')
325
372
        self.index_client.index_charm(four)
326
 
        result = self.get_charms(**{filter_str: 'common'})
 
373
        result = self.get_charms_and_bundles(**{filter_str: 'common'})
327
374
        self.assertEqual(2, len(result))
328
375
        self.assertEqual(set([one['store_url'], two['store_url']]),
329
376
                         set(charm['store_url'] for charm in result))
330
 
        result = self.get_charms(**{filter_str: 'different'})
 
377
        result = self.get_charms_and_bundles(**{filter_str: 'different'})
331
378
        self.assertEqual(set([three['store_url']]),
332
379
                         set(charm['store_url'] for charm in result))
333
380
        self.assertEqual(1, len(result))
334
 
        result = self.get_charms(**{filter_str: ['different', 'common']})
 
381
        result = self.get_charms_and_bundles(
 
382
            **{filter_str: ['different', 'common']})
335
383
        self.assertEqual(3, len(result))
336
384
 
337
385
    def test_charms_name_filter(self):
369
417
        """
370
418
        self.makeCharm(owner='alice', promulgated=True)
371
419
        self.makeCharm(owner='steve')
372
 
        result = self.get_charms(type_='community')
 
420
        result = self.get_charms_and_bundles(type_='community')
373
421
        self.assertEqual(['steve'], [charm['owner'] for charm in result])
374
 
        result = self.get_charms(type_='approved')
 
422
        result = self.get_charms_and_bundles(type_='approved')
375
423
        self.assertEqual(['alice'], [charm['owner'] for charm in result])
376
 
        result = self.get_charms(type_='environment')
 
424
        result = self.get_charms_and_bundles(type_='environment')
377
425
        self.assertEqual([], [charm['owner'] for charm in result])
378
426
        with self.assertRaises(InvalidCharmType):
379
 
            self.get_charms(type_='foo')
380
 
        result = self.get_charms(type_=['approved', 'community'])
 
427
            self.get_charms_and_bundles(type_='foo')
 
428
        result = self.get_charms_and_bundles(type_=['approved', 'community'])
381
429
        self.assertEqual(['alice', 'steve'],
382
430
                         [charm['owner'] for charm in result])
383
431
 
384
432
    def test_type_search_considers_promulgated(self):
385
433
        reviewed = self.makeCharm(promulgated=True)['_id']
386
434
        self.makeCharm(promulgated=False)
387
 
        results = self.get_charms(type_=['approved'])
 
435
        results = self.get_charms_and_bundles(type_=['approved'])
388
436
        self.assertEqual([reviewed], [result['_id'] for result in results])
389
437
 
390
438
    def test_charms_text_search(self):
391
439
        abc_charm = self.makeCharm(summary='abc def')
392
440
        self.makeCharm(summary='ghi jkl')
393
 
        charms = self.get_charms(text='def')
 
441
        charms = self.get_charms_and_bundles(text='def')
394
442
        self.assertEqual(1, len(charms))
395
443
        self.assertEqual(abc_charm['_id'], charms[0]['_id'])
396
444
 
399
447
        self.makeCharm(promulgated=True)
400
448
        self.makeCharm(summary='abc def', owner='steve')
401
449
        self.makeCharm(owner='steve')
402
 
        result = self.get_charms(type_=['approved'], text='def')
 
450
        result = self.get_charms_and_bundles(type_=['approved'], text='def')
403
451
        self.assertEqual([official['_id']],
404
452
                         [charm['_id'] for charm in result])
405
453
 
422
470
        """api_search() does not return charms withs errors by default."""
423
471
        self.makeCharm(name='evil-charm', charm_error=True)
424
472
        self.makeCharm(name='good-charm')
 
473
        self.makeBundle(name='great-bundle')
425
474
        result = self.index_client.api_search('', {}, None)
426
 
        self.assertEqual(1, len(result))
427
 
        self.assertEqual('good-charm', result[0]['name'])
 
475
        self.assertEqual(2, len(result))
 
476
        names = set(charm['name'] for charm in result)
 
477
        self.assertEqual(set(('good-charm', 'great-bundle')), names)
428
478
        # Charms with error are included in the search result
429
 
        # if the parameter valid_charms_only is set to False.
 
479
        # if the parameter valid_only is set to False.  Bundles are
 
480
        # always included.
430
481
        result = self.index_client.api_search(
431
 
            '', {}, None, valid_charms_only=False)
432
 
        self.assertEqual(2, len(result))
 
482
            '', {}, None, valid_only=False)
 
483
        self.assertEqual(3, len(result))
433
484
        names = set(charm['name'] for charm in result)
434
 
        self.assertEqual(set(('good-charm', 'evil-charm')), names)
 
485
        self.assertEqual(
 
486
            set(('good-charm', 'evil-charm', 'great-bundle')), names)
435
487
 
436
488
    def test_search_charm_with_store_error(self):
437
489
        """search() does not return charms withs errors by default."""
438
490
        self.makeCharm(name='evil-charm', owner='foo', charm_error=True)
439
491
        self.makeCharm(name='good-charm', owner='foo')
 
492
        self.makeBundle(name='great-bundle', owner='foo')
440
493
        result = self.index_client.search('foo')
441
 
        self.assertEqual(1, result['matches'])
442
 
        self.assertEqual('good-charm', result['results'][0]['data'].name)
443
 
        # Charms with error are included in the search result
444
 
        # if the parameter valid_charms_only is set to False.
445
 
        result = self.index_client.search('foo', valid_charms_only=False)
446
494
        self.assertEqual(2, result['matches'])
447
 
        names = set(entry['data'].name for entry in result['results'])
448
 
        self.assertEqual(set(('good-charm', 'evil-charm')), names)
 
495
        data = result['results']['charm'][0]['data']
 
496
        self.assertEqual('good-charm', data.name)
 
497
        data = result['results']['bundle'][0]['data']
 
498
        self.assertEqual('great-bundle', data.name)
 
499
        # Charms with error are included in the search result
 
500
        # if the parameter valid_only is set to False.
 
501
        result = self.index_client.search('foo', valid_only=False)
 
502
        self.assertEqual(3, result['matches'])
 
503
        names = set(e['data'].name for e in result['results']['charm'])
 
504
        names.update(set(e['data'].name for e in result['results']['bundle']))
 
505
        self.assertEqual(
 
506
            set(('good-charm', 'evil-charm', 'great-bundle')), names)
449
507
 
450
508
    def test_search_charm_with_error(self):
451
509
        """searches include charms with processing errors."""
452
510
        charm = Charm(self.makeCharm())
453
511
        result = self.index_client.search(charm.name)
454
 
        self.assertEqual(charm, result['results'][0]['data'])
 
512
        self.assertEqual(charm, result['results']['charm'][0]['data'])
455
513
        charm._representation['error'] = {'error': 'error text'}
456
514
        self.index_client.index_charm(charm._representation)
457
515
        result = self.index_client.search(charm.name)
458
 
        self.assertEqual(charm, result['results'][0]['data'])
 
516
        self.assertEqual(charm, result['results']['charm'][0]['data'])
459
517
 
460
518
    def test_api_search_charm_with_error(self):
461
519
        """Search results include charms with processing errors."""