1 # -*- coding: utf-8 -*- |
|
2 # copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
|
3 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
|
4 # |
|
5 # This file is part of CubicWeb. |
|
6 # |
|
7 # CubicWeb is free software: you can redistribute it and/or modify it under the |
|
8 # terms of the GNU Lesser General Public License as published by the Free |
|
9 # Software Foundation, either version 2.1 of the License, or (at your option) |
|
10 # any later version. |
|
11 # |
|
12 # CubicWeb is distributed in the hope that it will be useful, but WITHOUT |
|
13 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
|
14 # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more |
|
15 # details. |
|
16 # |
|
17 # You should have received a copy of the GNU Lesser General Public License along |
|
18 # with CubicWeb. If not, see <http://www.gnu.org/licenses/>. |
|
19 """Unit tests for cw.web.views.magicsearch""" |
|
20 |
|
21 import sys |
|
22 from contextlib import contextmanager |
|
23 |
|
24 from six.moves import range |
|
25 |
|
26 from logilab.common.testlib import TestCase, unittest_main |
|
27 |
|
28 from rql import BadRQLQuery, RQLSyntaxError |
|
29 |
|
30 from cubicweb.devtools.testlib import CubicWebTC |
|
31 |
|
32 |
|
33 translations = { |
|
34 u'CWUser' : u"Utilisateur", |
|
35 u'EmailAddress' : u"Adresse", |
|
36 u'name' : u"nom", |
|
37 u'alias' : u"nom", |
|
38 u'surname' : u"nom", |
|
39 u'firstname' : u"prénom", |
|
40 u'state' : u"état", |
|
41 u'address' : u"adresse", |
|
42 u'use_email' : u"adel", |
|
43 } |
|
44 |
|
45 def _translate(msgid): |
|
46 return translations.get(msgid, msgid) |
|
47 |
|
48 def _ctxtranslate(ctx, msgid): |
|
49 return _translate(msgid) |
|
50 |
|
51 from cubicweb.web.views.magicsearch import translate_rql_tree, QSPreProcessor, QueryTranslator |
|
52 |
|
53 class QueryTranslatorTC(CubicWebTC): |
|
54 """test suite for QueryTranslatorTC""" |
|
55 |
|
56 @contextmanager |
|
57 def proc(self): |
|
58 with self.admin_access.web_request() as req: |
|
59 self.vreg.config.translations = {'en': (_translate, _ctxtranslate)} |
|
60 proc = self.vreg['components'].select('magicsearch', req) |
|
61 proc = [p for p in proc.processors if isinstance(p, QueryTranslator)][0] |
|
62 yield proc |
|
63 |
|
64 def test_basic_translations(self): |
|
65 """tests basic translations (no ambiguities)""" |
|
66 with self.proc() as proc: |
|
67 rql = u"Any C WHERE C is Adresse, P adel C, C adresse 'Logilab'" |
|
68 rql, = proc.preprocess_query(rql) |
|
69 self.assertEqual(rql, 'Any C WHERE C is EmailAddress, P use_email C, C address "Logilab"') |
|
70 |
|
71 def test_ambiguous_translations(self): |
|
72 """tests possibly ambiguous translations""" |
|
73 with self.proc() as proc: |
|
74 rql = u"Any P WHERE P adel C, C is EmailAddress, C nom 'Logilab'" |
|
75 rql, = proc.preprocess_query(rql) |
|
76 self.assertEqual(rql, 'Any P WHERE P use_email C, C is EmailAddress, C alias "Logilab"') |
|
77 rql = u"Any P WHERE P is Utilisateur, P adel C, P nom 'Smith'" |
|
78 rql, = proc.preprocess_query(rql) |
|
79 self.assertEqual(rql, 'Any P WHERE P is CWUser, P use_email C, P surname "Smith"') |
|
80 |
|
81 |
|
82 class QSPreProcessorTC(CubicWebTC): |
|
83 """test suite for QSPreProcessor""" |
|
84 |
|
85 @contextmanager |
|
86 def proc(self): |
|
87 self.vreg.config.translations = {'en': (_translate, _ctxtranslate)} |
|
88 with self.admin_access.web_request() as req: |
|
89 proc = self.vreg['components'].select('magicsearch', req) |
|
90 proc = [p for p in proc.processors if isinstance(p, QSPreProcessor)][0] |
|
91 proc._cw = req |
|
92 yield proc |
|
93 |
|
94 def test_entity_translation(self): |
|
95 """tests QSPreProcessor._get_entity_name()""" |
|
96 with self.proc() as proc: |
|
97 translate = proc._get_entity_type |
|
98 self.assertEqual(translate(u'EmailAddress'), "EmailAddress") |
|
99 self.assertEqual(translate(u'emailaddress'), "EmailAddress") |
|
100 self.assertEqual(translate(u'Adresse'), "EmailAddress") |
|
101 self.assertEqual(translate(u'adresse'), "EmailAddress") |
|
102 self.assertRaises(BadRQLQuery, translate, 'whatever') |
|
103 |
|
104 def test_attribute_translation(self): |
|
105 """tests QSPreProcessor._get_attribute_name""" |
|
106 with self.proc() as proc: |
|
107 translate = proc._get_attribute_name |
|
108 eschema = self.schema.eschema('CWUser') |
|
109 self.assertEqual(translate(u'prénom', eschema), "firstname") |
|
110 self.assertEqual(translate(u'nom', eschema), 'surname') |
|
111 eschema = self.schema.eschema('EmailAddress') |
|
112 self.assertEqual(translate(u'adresse', eschema), "address") |
|
113 self.assertEqual(translate(u'nom', eschema), 'alias') |
|
114 # should fail if the name is not an attribute for the given entity schema |
|
115 self.assertRaises(BadRQLQuery, translate, 'whatever', eschema) |
|
116 self.assertRaises(BadRQLQuery, translate, 'prénom', eschema) |
|
117 |
|
118 def test_one_word_query(self): |
|
119 """tests the 'one word shortcut queries'""" |
|
120 with self.proc() as proc: |
|
121 transform = proc._one_word_query |
|
122 self.assertEqual(transform('123'), |
|
123 ('Any X WHERE X eid %(x)s', {'x': 123}, 'x')) |
|
124 self.assertEqual(transform('CWUser'), |
|
125 ('CWUser C',)) |
|
126 self.assertEqual(transform('Utilisateur'), |
|
127 ('CWUser C',)) |
|
128 self.assertEqual(transform('Adresse'), |
|
129 ('EmailAddress E',)) |
|
130 self.assertEqual(transform('adresse'), |
|
131 ('EmailAddress E',)) |
|
132 self.assertRaises(BadRQLQuery, transform, 'Workcases') |
|
133 |
|
134 def test_two_words_query(self): |
|
135 """tests the 'two words shortcut queries'""" |
|
136 with self.proc() as proc: |
|
137 transform = proc._two_words_query |
|
138 self.assertEqual(transform('CWUser', 'E'), |
|
139 ("CWUser E",)) |
|
140 self.assertEqual(transform('CWUser', 'Smith'), |
|
141 ('CWUser C ORDERBY FTIRANK(C) DESC WHERE C has_text %(text)s', {'text': 'Smith'})) |
|
142 self.assertEqual(transform('utilisateur', 'Smith'), |
|
143 ('CWUser C ORDERBY FTIRANK(C) DESC WHERE C has_text %(text)s', {'text': 'Smith'})) |
|
144 self.assertEqual(transform(u'adresse', 'Logilab'), |
|
145 ('EmailAddress E ORDERBY FTIRANK(E) DESC WHERE E has_text %(text)s', {'text': 'Logilab'})) |
|
146 self.assertEqual(transform(u'adresse', 'Logi%'), |
|
147 ('EmailAddress E WHERE E alias LIKE %(text)s', {'text': 'Logi%'})) |
|
148 self.assertRaises(BadRQLQuery, transform, "pers", "taratata") |
|
149 |
|
150 def test_three_words_query(self): |
|
151 """tests the 'three words shortcut queries'""" |
|
152 with self.proc() as proc: |
|
153 transform = proc._three_words_query |
|
154 self.assertEqual(transform('utilisateur', u'prénom', 'cubicweb'), |
|
155 ('CWUser C WHERE C firstname %(text)s', {'text': 'cubicweb'})) |
|
156 self.assertEqual(transform('utilisateur', 'nom', 'cubicweb'), |
|
157 ('CWUser C WHERE C surname %(text)s', {'text': 'cubicweb'})) |
|
158 self.assertEqual(transform(u'adresse', 'nom', 'cubicweb'), |
|
159 ('EmailAddress E WHERE E alias %(text)s', {'text': 'cubicweb'})) |
|
160 self.assertEqual(transform('EmailAddress', 'nom', 'cubicweb'), |
|
161 ('EmailAddress E WHERE E alias %(text)s', {'text': 'cubicweb'})) |
|
162 self.assertEqual(transform('utilisateur', u'prénom', 'cubicweb%'), |
|
163 ('CWUser C WHERE C firstname LIKE %(text)s', {'text': 'cubicweb%'})) |
|
164 # expanded shortcuts |
|
165 self.assertEqual(transform('CWUser', 'use_email', 'Logilab'), |
|
166 ('CWUser C ORDERBY FTIRANK(C1) DESC WHERE C use_email C1, C1 has_text %(text)s', {'text': 'Logilab'})) |
|
167 self.assertEqual(transform('CWUser', 'use_email', '%Logilab'), |
|
168 ('CWUser C WHERE C use_email C1, C1 alias LIKE %(text)s', {'text': '%Logilab'})) |
|
169 self.assertRaises(BadRQLQuery, transform, 'word1', 'word2', 'word3') |
|
170 |
|
171 def test_quoted_queries(self): |
|
172 """tests how quoted queries are handled""" |
|
173 queries = [ |
|
174 (u'Adresse "My own EmailAddress"', ('EmailAddress E ORDERBY FTIRANK(E) DESC WHERE E has_text %(text)s', {'text': u'My own EmailAddress'})), |
|
175 (u'Utilisateur prénom "Jean Paul"', ('CWUser C WHERE C firstname %(text)s', {'text': 'Jean Paul'})), |
|
176 (u'Utilisateur firstname "Jean Paul"', ('CWUser C WHERE C firstname %(text)s', {'text': 'Jean Paul'})), |
|
177 (u'CWUser firstname "Jean Paul"', ('CWUser C WHERE C firstname %(text)s', {'text': 'Jean Paul'})), |
|
178 ] |
|
179 with self.proc() as proc: |
|
180 transform = proc._quoted_words_query |
|
181 for query, expected in queries: |
|
182 self.assertEqual(transform(query), expected) |
|
183 self.assertRaises(BadRQLQuery, transform, "unquoted rql") |
|
184 self.assertRaises(BadRQLQuery, transform, 'pers "Jean Paul"') |
|
185 self.assertRaises(BadRQLQuery, transform, 'CWUser firstname other "Jean Paul"') |
|
186 |
|
187 def test_process_query(self): |
|
188 """tests how queries are processed""" |
|
189 queries = [ |
|
190 (u'Utilisateur', (u"CWUser C",)), |
|
191 (u'Utilisateur P', (u"CWUser P",)), |
|
192 (u'Utilisateur cubicweb', (u'CWUser C ORDERBY FTIRANK(C) DESC WHERE C has_text %(text)s', {'text': u'cubicweb'})), |
|
193 (u'CWUser prénom cubicweb', (u'CWUser C WHERE C firstname %(text)s', {'text': 'cubicweb'},)), |
|
194 ] |
|
195 with self.proc() as proc: |
|
196 for query, expected in queries: |
|
197 self.assertEqual(proc.preprocess_query(query), expected) |
|
198 self.assertRaises(BadRQLQuery, |
|
199 proc.preprocess_query, 'Any X WHERE X is Something') |
|
200 |
|
201 |
|
202 |
|
203 ## Processor Chains tests ############################################ |
|
204 |
|
205 class ProcessorChainTC(CubicWebTC): |
|
206 """test suite for magic_search's processor chains""" |
|
207 |
|
208 @contextmanager |
|
209 def proc(self): |
|
210 self.vreg.config.translations = {'en': (_translate, _ctxtranslate)} |
|
211 with self.admin_access.web_request() as req: |
|
212 proc = self.vreg['components'].select('magicsearch', req) |
|
213 yield proc |
|
214 |
|
215 def test_main_preprocessor_chain(self): |
|
216 """tests QUERY_PROCESSOR""" |
|
217 queries = [ |
|
218 (u'foo', |
|
219 ("Any X ORDERBY FTIRANK(X) DESC WHERE X has_text %(text)s", {'text': u'foo'})), |
|
220 # XXX this sounds like a language translator test... |
|
221 # and it fails |
|
222 (u'Utilisateur Smith', |
|
223 ('CWUser C ORDERBY FTIRANK(C) DESC WHERE C has_text %(text)s', {'text': u'Smith'})), |
|
224 (u'utilisateur nom Smith', |
|
225 ('CWUser C WHERE C surname %(text)s', {'text': u'Smith'})), |
|
226 (u'Any P WHERE P is Utilisateur, P nom "Smith"', |
|
227 ('Any P WHERE P is CWUser, P surname "Smith"', None)), |
|
228 ] |
|
229 with self.proc() as proc: |
|
230 for query, expected in queries: |
|
231 rset = proc.process_query(query) |
|
232 self.assertEqual((rset.rql, rset.args), expected) |
|
233 |
|
234 def test_accentuated_fulltext(self): |
|
235 """we must be able to type accentuated characters in the search field""" |
|
236 with self.proc() as proc: |
|
237 rset = proc.process_query(u'écrire') |
|
238 self.assertEqual(rset.rql, "Any X ORDERBY FTIRANK(X) DESC WHERE X has_text %(text)s") |
|
239 self.assertEqual(rset.args, {'text': u'écrire'}) |
|
240 |
|
241 def test_explicit_component(self): |
|
242 with self.proc() as proc: |
|
243 self.assertRaises(RQLSyntaxError, |
|
244 proc.process_query, u'rql: CWUser E WHERE E noattr "Smith",') |
|
245 self.assertRaises(BadRQLQuery, |
|
246 proc.process_query, u'rql: CWUser E WHERE E noattr "Smith"') |
|
247 rset = proc.process_query(u'text: utilisateur Smith') |
|
248 self.assertEqual(rset.rql, 'Any X ORDERBY FTIRANK(X) DESC WHERE X has_text %(text)s') |
|
249 self.assertEqual(rset.args, {'text': u'utilisateur Smith'}) |
|
250 |
|
251 |
|
252 class RQLSuggestionsBuilderTC(CubicWebTC): |
|
253 def suggestions(self, rql): |
|
254 with self.admin_access.web_request() as req: |
|
255 rbs = self.vreg['components'].select('rql.suggestions', req) |
|
256 return rbs.build_suggestions(rql) |
|
257 |
|
258 def test_no_restrictions_rql(self): |
|
259 self.assertListEqual([], self.suggestions('')) |
|
260 self.assertListEqual([], self.suggestions('An')) |
|
261 self.assertListEqual([], self.suggestions('Any X')) |
|
262 self.assertListEqual([], self.suggestions('Any X, Y')) |
|
263 |
|
264 def test_invalid_rql(self): |
|
265 self.assertListEqual([], self.suggestions('blabla')) |
|
266 self.assertListEqual([], self.suggestions('Any X WHERE foo, bar')) |
|
267 |
|
268 def test_is_rql(self): |
|
269 self.assertListEqual(['Any X WHERE X is %s' % eschema |
|
270 for eschema in sorted(self.vreg.schema.entities()) |
|
271 if not eschema.final], |
|
272 self.suggestions('Any X WHERE X is')) |
|
273 |
|
274 self.assertListEqual(['Any X WHERE X is Personne', 'Any X WHERE X is Project'], |
|
275 self.suggestions('Any X WHERE X is P')) |
|
276 |
|
277 self.assertListEqual(['Any X WHERE X is Personne, Y is Personne', |
|
278 'Any X WHERE X is Personne, Y is Project'], |
|
279 self.suggestions('Any X WHERE X is Personne, Y is P')) |
|
280 |
|
281 |
|
282 def test_relations_rql(self): |
|
283 self.assertListEqual(['Any X WHERE X is Personne, X ass A', |
|
284 'Any X WHERE X is Personne, X datenaiss A', |
|
285 'Any X WHERE X is Personne, X description A', |
|
286 'Any X WHERE X is Personne, X fax A', |
|
287 'Any X WHERE X is Personne, X nom A', |
|
288 'Any X WHERE X is Personne, X prenom A', |
|
289 'Any X WHERE X is Personne, X promo A', |
|
290 'Any X WHERE X is Personne, X salary A', |
|
291 'Any X WHERE X is Personne, X sexe A', |
|
292 'Any X WHERE X is Personne, X tel A', |
|
293 'Any X WHERE X is Personne, X test A', |
|
294 'Any X WHERE X is Personne, X titre A', |
|
295 'Any X WHERE X is Personne, X travaille A', |
|
296 'Any X WHERE X is Personne, X web A', |
|
297 ], |
|
298 self.suggestions('Any X WHERE X is Personne, X ')) |
|
299 self.assertListEqual(['Any X WHERE X is Personne, X tel A', |
|
300 'Any X WHERE X is Personne, X test A', |
|
301 'Any X WHERE X is Personne, X titre A', |
|
302 'Any X WHERE X is Personne, X travaille A', |
|
303 ], |
|
304 self.suggestions('Any X WHERE X is Personne, X t')) |
|
305 # try completion on selected |
|
306 self.assertListEqual(['Any X WHERE X is Personne, Y is Societe, X tel A', |
|
307 'Any X WHERE X is Personne, Y is Societe, X test A', |
|
308 'Any X WHERE X is Personne, Y is Societe, X titre A', |
|
309 'Any X WHERE X is Personne, Y is Societe, X travaille Y', |
|
310 ], |
|
311 self.suggestions('Any X WHERE X is Personne, Y is Societe, X t')) |
|
312 # invalid relation should not break |
|
313 self.assertListEqual([], |
|
314 self.suggestions('Any X WHERE X is Personne, X asdasd')) |
|
315 |
|
316 def test_attribute_vocabulary_rql(self): |
|
317 self.assertListEqual(['Any X WHERE X is Personne, X promo "bon"', |
|
318 'Any X WHERE X is Personne, X promo "pasbon"', |
|
319 ], |
|
320 self.suggestions('Any X WHERE X is Personne, X promo "')) |
|
321 self.assertListEqual(['Any X WHERE X is Personne, X promo "pasbon"', |
|
322 ], |
|
323 self.suggestions('Any X WHERE X is Personne, X promo "p')) |
|
324 # "bon" should be considered complete, hence no suggestion |
|
325 self.assertListEqual([], |
|
326 self.suggestions('Any X WHERE X is Personne, X promo "bon"')) |
|
327 # no valid vocabulary starts with "po" |
|
328 self.assertListEqual([], |
|
329 self.suggestions('Any X WHERE X is Personne, X promo "po')) |
|
330 |
|
331 def test_attribute_value_rql(self): |
|
332 # suggestions should contain any possible value for |
|
333 # a given attribute (limited to 10) |
|
334 with self.admin_access.web_request() as req: |
|
335 for i in range(15): |
|
336 req.create_entity('Personne', nom=u'n%s' % i, prenom=u'p%s' % i) |
|
337 req.cnx.commit() |
|
338 self.assertListEqual(['Any X WHERE X is Personne, X nom "n0"', |
|
339 'Any X WHERE X is Personne, X nom "n1"', |
|
340 'Any X WHERE X is Personne, X nom "n10"', |
|
341 'Any X WHERE X is Personne, X nom "n11"', |
|
342 'Any X WHERE X is Personne, X nom "n12"', |
|
343 'Any X WHERE X is Personne, X nom "n13"', |
|
344 'Any X WHERE X is Personne, X nom "n14"', |
|
345 'Any X WHERE X is Personne, X nom "n2"', |
|
346 'Any X WHERE X is Personne, X nom "n3"', |
|
347 'Any X WHERE X is Personne, X nom "n4"', |
|
348 'Any X WHERE X is Personne, X nom "n5"', |
|
349 'Any X WHERE X is Personne, X nom "n6"', |
|
350 'Any X WHERE X is Personne, X nom "n7"', |
|
351 'Any X WHERE X is Personne, X nom "n8"', |
|
352 'Any X WHERE X is Personne, X nom "n9"', |
|
353 ], |
|
354 self.suggestions('Any X WHERE X is Personne, X nom "')) |
|
355 self.assertListEqual(['Any X WHERE X is Personne, X nom "n1"', |
|
356 'Any X WHERE X is Personne, X nom "n10"', |
|
357 'Any X WHERE X is Personne, X nom "n11"', |
|
358 'Any X WHERE X is Personne, X nom "n12"', |
|
359 'Any X WHERE X is Personne, X nom "n13"', |
|
360 'Any X WHERE X is Personne, X nom "n14"', |
|
361 ], |
|
362 self.suggestions('Any X WHERE X is Personne, X nom "n1')) |
|
363 |
|
364 |
|
365 if __name__ == '__main__': |
|
366 unittest_main() |
|