1 from logilab.common.date import datetime2ticks |
|
2 from cubicweb.devtools.testlib import CubicWebTC |
|
3 from cubicweb.web import facet |
|
4 |
|
5 class BaseFacetTC(CubicWebTC): |
|
6 |
|
7 def prepare_rqlst(self, req, rql='CWUser X', mainvar='X', |
|
8 expected_baserql='Any X WHERE X is CWUser', |
|
9 expected_preparedrql='DISTINCT Any WHERE X is CWUser'): |
|
10 rset = req.cnx.execute(rql) |
|
11 rqlst = rset.syntax_tree().copy() |
|
12 filtered_variable, baserql = facet.init_facets(rset, rqlst.children[0], |
|
13 mainvar=mainvar) |
|
14 self.assertEqual(filtered_variable.name, mainvar) |
|
15 self.assertEqual(baserql, expected_baserql) |
|
16 self.assertEqual(rqlst.as_string(), expected_preparedrql) |
|
17 return rset, rqlst, filtered_variable |
|
18 |
|
19 def _in_group_facet(self, req, cls=facet.RelationFacet, no_relation=False): |
|
20 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
21 cls.no_relation = no_relation |
|
22 f = cls(req, rset=rset, select=rqlst.children[0], |
|
23 filtered_variable=filtered_variable) |
|
24 f.__regid__ = 'in_group' |
|
25 f.rtype = 'in_group' |
|
26 f.role = 'subject' |
|
27 f.target_attr = 'name' |
|
28 guests, managers = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN ' |
|
29 'WHERE G name GN, G name IN ("guests", "managers")')] |
|
30 groups = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN ' |
|
31 'WHERE G name GN, G name IN ("guests", "managers")')] |
|
32 return f, groups |
|
33 |
|
34 def test_relation_simple(self): |
|
35 with self.admin_access.web_request() as req: |
|
36 f, (guests, managers) = self._in_group_facet(req) |
|
37 self.assertEqual(f.vocabulary(), |
|
38 [(u'guests', guests), (u'managers', managers)]) |
|
39 # ensure rqlst is left unmodified |
|
40 self.assertEqual(f.select.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
41 #rqlst = rset.syntax_tree() |
|
42 self.assertEqual(f.possible_values(), |
|
43 [str(guests), str(managers)]) |
|
44 # ensure rqlst is left unmodified |
|
45 self.assertEqual(f.select.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
46 f._cw.form[f.__regid__] = str(guests) |
|
47 f.add_rql_restrictions() |
|
48 # selection is cluttered because rqlst has been prepared for facet (it |
|
49 # is not in real life) |
|
50 self.assertEqual(f.select.as_string(), |
|
51 'DISTINCT Any WHERE X is CWUser, X in_group D, D eid %s' % guests) |
|
52 |
|
53 def test_relation_multiple_and(self): |
|
54 with self.admin_access.web_request() as req: |
|
55 f, (guests, managers) = self._in_group_facet(req) |
|
56 f._cw.form[f.__regid__] = [str(guests), str(managers)] |
|
57 f._cw.form[f.__regid__ + '_andor'] = 'AND' |
|
58 f.add_rql_restrictions() |
|
59 self.assertEqual(f.select.as_string(), |
|
60 'DISTINCT Any WHERE X is CWUser, X in_group A, B eid %s, X in_group B, A eid %s' % (guests, managers)) |
|
61 |
|
62 def test_relation_multiple_or(self): |
|
63 with self.admin_access.web_request() as req: |
|
64 f, (guests, managers) = self._in_group_facet(req) |
|
65 f._cw.form[f.__regid__] = [str(guests), str(managers)] |
|
66 f._cw.form[f.__regid__ + '_andor'] = 'OR' |
|
67 f.add_rql_restrictions() |
|
68 self.assertEqual(f.select.as_string(), |
|
69 'DISTINCT Any WHERE X is CWUser, X in_group A, A eid IN(%s, %s)' % (guests, managers)) |
|
70 |
|
71 def test_relation_optional_rel(self): |
|
72 with self.admin_access.web_request() as req: |
|
73 rset = req.cnx.execute(u'Any X,GROUP_CONCAT(GN) GROUPBY X ' |
|
74 'WHERE X in_group G?, G name GN, NOT G name "users"') |
|
75 rqlst = rset.syntax_tree().copy() |
|
76 select = rqlst.children[0] |
|
77 filtered_variable, baserql = facet.init_facets(rset, select) |
|
78 |
|
79 f = facet.RelationFacet(req, rset=rset, |
|
80 select=select, |
|
81 filtered_variable=filtered_variable) |
|
82 f.rtype = 'in_group' |
|
83 f.role = 'subject' |
|
84 f.target_attr = 'name' |
|
85 guests, managers = [eid for eid, in req.cnx.execute('CWGroup G ORDERBY GN ' |
|
86 'WHERE G name GN, G name IN ("guests", "managers")')] |
|
87 self.assertEqual(f.vocabulary(), |
|
88 [(u'guests', guests), (u'managers', managers)]) |
|
89 # ensure rqlst is left unmodified |
|
90 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X in_group G?, G name GN, NOT G name "users"') |
|
91 #rqlst = rset.syntax_tree() |
|
92 self.assertEqual(sorted(f.possible_values()), |
|
93 [str(guests), str(managers)]) |
|
94 # ensure rqlst is left unmodified |
|
95 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X in_group G?, G name GN, NOT G name "users"') |
|
96 req.form[f.__regid__] = str(guests) |
|
97 f.add_rql_restrictions() |
|
98 # selection is cluttered because rqlst has been prepared for facet (it |
|
99 # is not in real life) |
|
100 self.assertEqual(f.select.as_string(), |
|
101 'DISTINCT Any WHERE X in_group G?, G name GN, NOT G name "users", X in_group D, D eid %s' % guests) |
|
102 |
|
103 def test_relation_no_relation_1(self): |
|
104 with self.admin_access.web_request() as req: |
|
105 f, (guests, managers) = self._in_group_facet(req, no_relation=True) |
|
106 self.assertEqual(f.vocabulary(), |
|
107 [(u'guests', guests), (u'managers', managers)]) |
|
108 self.assertEqual(f.possible_values(), |
|
109 [str(guests), str(managers)]) |
|
110 f._cw.create_entity('CWUser', login=u'hop', upassword='toto') |
|
111 self.assertEqual(f.vocabulary(), |
|
112 [(u'<no relation>', ''), (u'guests', guests), (u'managers', managers)]) |
|
113 self.assertEqual(f.possible_values(), |
|
114 [str(guests), str(managers), '']) |
|
115 f._cw.form[f.__regid__] = '' |
|
116 f.add_rql_restrictions() |
|
117 self.assertEqual(f.select.as_string(), |
|
118 'DISTINCT Any WHERE X is CWUser, NOT X in_group G') |
|
119 |
|
120 def test_relation_no_relation_2(self): |
|
121 with self.admin_access.web_request() as req: |
|
122 f, (guests, managers) = self._in_group_facet(req, no_relation=True) |
|
123 f._cw.form[f.__regid__] = ['', guests] |
|
124 f.select.save_state() |
|
125 f.add_rql_restrictions() |
|
126 self.assertEqual(f.select.as_string(), |
|
127 'DISTINCT Any WHERE X is CWUser, (NOT X in_group B) OR (X in_group A, A eid %s)' % guests) |
|
128 f.select.recover() |
|
129 self.assertEqual(f.select.as_string(), |
|
130 'DISTINCT Any WHERE X is CWUser') |
|
131 |
|
132 def test_relationattribute(self): |
|
133 with self.admin_access.web_request() as req: |
|
134 f, (guests, managers) = self._in_group_facet(req, cls=facet.RelationAttributeFacet) |
|
135 self.assertEqual(f.vocabulary(), |
|
136 [(u'guests', u'guests'), (u'managers', u'managers')]) |
|
137 # ensure rqlst is left unmodified |
|
138 self.assertEqual(f.select.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
139 #rqlst = rset.syntax_tree() |
|
140 self.assertEqual(f.possible_values(), |
|
141 ['guests', 'managers']) |
|
142 # ensure rqlst is left unmodified |
|
143 self.assertEqual(f.select.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
144 f._cw.form[f.__regid__] = u'guests' |
|
145 f.add_rql_restrictions() |
|
146 # selection is cluttered because rqlst has been prepared for facet (it |
|
147 # is not in real life) |
|
148 self.assertEqual(f.select.as_string(), |
|
149 'DISTINCT Any WHERE X is CWUser, X in_group E, E name "guests"') |
|
150 |
|
151 def test_hasrelation(self): |
|
152 with self.admin_access.web_request() as req: |
|
153 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
154 f = facet.HasRelationFacet(req, rset=rset, |
|
155 select=rqlst.children[0], |
|
156 filtered_variable=filtered_variable) |
|
157 f.__regid__ = 'has_group' |
|
158 f.rtype = 'in_group' |
|
159 f.role = 'subject' |
|
160 f._cw.form[f.__regid__] = 'feed me' |
|
161 f.add_rql_restrictions() |
|
162 self.assertEqual(f.select.as_string(), |
|
163 'DISTINCT Any WHERE X is CWUser, EXISTS(X in_group A)') |
|
164 |
|
165 def test_daterange(self): |
|
166 with self.admin_access.web_request() as req: |
|
167 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
168 f = facet.DateRangeFacet(req, rset=rset, |
|
169 select=rqlst.children[0], |
|
170 filtered_variable=filtered_variable) |
|
171 f.rtype = 'creation_date' |
|
172 mind, maxd = req.cnx.execute('Any MIN(CD), MAX(CD) WHERE X is CWUser, X creation_date CD')[0] |
|
173 self.assertEqual(f.vocabulary(), |
|
174 [(str(mind), mind), |
|
175 (str(maxd), maxd)]) |
|
176 # ensure rqlst is left unmodified |
|
177 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
178 #rqlst = rset.syntax_tree() |
|
179 self.assertEqual(f.possible_values(), |
|
180 [str(mind), str(maxd)]) |
|
181 # ensure rqlst is left unmodified |
|
182 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
183 req.form['%s_inf' % f.__regid__] = str(datetime2ticks(mind)) |
|
184 req.form['%s_sup' % f.__regid__] = str(datetime2ticks(mind)) |
|
185 f.add_rql_restrictions() |
|
186 # selection is cluttered because rqlst has been prepared for facet (it |
|
187 # is not in real life) |
|
188 self.assertEqual(f.select.as_string(), |
|
189 'DISTINCT Any WHERE X is CWUser, X creation_date >= "%s", ' |
|
190 'X creation_date <= "%s"' |
|
191 % (mind.strftime('%Y/%m/%d'), |
|
192 mind.strftime('%Y/%m/%d'))) |
|
193 |
|
194 def test_attribute(self): |
|
195 with self.admin_access.web_request() as req: |
|
196 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
197 f = facet.AttributeFacet(req, rset=rset, |
|
198 select=rqlst.children[0], |
|
199 filtered_variable=filtered_variable) |
|
200 f.rtype = 'login' |
|
201 self.assertEqual(f.vocabulary(), |
|
202 [(u'admin', u'admin'), (u'anon', u'anon')]) |
|
203 # ensure rqlst is left unmodified |
|
204 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
205 #rqlst = rset.syntax_tree() |
|
206 self.assertEqual(f.possible_values(), |
|
207 ['admin', 'anon']) |
|
208 # ensure rqlst is left unmodified |
|
209 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
210 req.form[f.__regid__] = u'admin' |
|
211 f.add_rql_restrictions() |
|
212 # selection is cluttered because rqlst has been prepared for facet (it |
|
213 # is not in real life) |
|
214 self.assertEqual(f.select.as_string(), |
|
215 'DISTINCT Any WHERE X is CWUser, X login "admin"') |
|
216 |
|
217 def test_bitfield(self): |
|
218 with self.admin_access.web_request() as req: |
|
219 rset, rqlst, filtered_variable = self.prepare_rqlst(req, |
|
220 'CWAttribute X WHERE X ordernum XO', |
|
221 expected_baserql='Any X WHERE X ordernum XO, X is CWAttribute', |
|
222 expected_preparedrql='DISTINCT Any WHERE X ordernum XO, X is CWAttribute') |
|
223 f = facet.BitFieldFacet(req, rset=rset, |
|
224 select=rqlst.children[0], |
|
225 filtered_variable=filtered_variable) |
|
226 f.choices = [('un', 1,), ('deux', 2,)] |
|
227 f.rtype = 'ordernum' |
|
228 self.assertEqual(f.vocabulary(), |
|
229 [(u'deux', 2), (u'un', 1)]) |
|
230 # ensure rqlst is left unmodified |
|
231 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X ordernum XO, X is CWAttribute') |
|
232 #rqlst = rset.syntax_tree() |
|
233 self.assertEqual(f.possible_values(), |
|
234 ['2', '1']) |
|
235 # ensure rqlst is left unmodified |
|
236 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X ordernum XO, X is CWAttribute') |
|
237 req.form[f.__regid__] = '3' |
|
238 f.add_rql_restrictions() |
|
239 # selection is cluttered because rqlst has been prepared for facet (it |
|
240 # is not in real life) |
|
241 self.assertEqual(f.select.as_string(), |
|
242 "DISTINCT Any WHERE X ordernum XO, X is CWAttribute, X ordernum C HAVING 3 = (C & 3)") |
|
243 |
|
244 def test_bitfield_0_value(self): |
|
245 with self.admin_access.web_request() as req: |
|
246 rset, rqlst, filtered_variable = self.prepare_rqlst(req, |
|
247 'CWAttribute X WHERE X ordernum XO', |
|
248 expected_baserql='Any X WHERE X ordernum XO, X is CWAttribute', |
|
249 expected_preparedrql='DISTINCT Any WHERE X ordernum XO, X is CWAttribute') |
|
250 f = facet.BitFieldFacet(req, rset=rset, |
|
251 select=rqlst.children[0], |
|
252 filtered_variable=filtered_variable) |
|
253 f.choices = [('zero', 0,), ('un', 1,), ('deux', 2,)] |
|
254 f.rtype = 'ordernum' |
|
255 self.assertEqual(f.vocabulary(), |
|
256 [(u'deux', 2), (u'un', 1), (u'zero', 0)]) |
|
257 self.assertEqual(f.possible_values(), |
|
258 ['2', '1', '0']) |
|
259 req.form[f.__regid__] = '0' |
|
260 f.add_rql_restrictions() |
|
261 self.assertEqual(f.select.as_string(), |
|
262 "DISTINCT Any WHERE X ordernum XO, X is CWAttribute, X ordernum C HAVING 0 = C") |
|
263 |
|
264 def test_rql_path_eid(self): |
|
265 with self.admin_access.web_request() as req: |
|
266 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
267 class RPF(facet.RQLPathFacet): |
|
268 path = [('X created_by U'), ('U owned_by O'), ('O login OL')] |
|
269 filter_variable = 'O' |
|
270 label_variable = 'OL' |
|
271 f = RPF(req, rset=rset, select=rqlst.children[0], |
|
272 filtered_variable=filtered_variable) |
|
273 self.assertEqual(f.vocabulary(), [(u'admin', req.user.eid),]) |
|
274 # ensure rqlst is left unmodified |
|
275 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
276 #rqlst = rset.syntax_tree() |
|
277 self.assertEqual(f.possible_values(), |
|
278 [str(req.user.eid),]) |
|
279 # ensure rqlst is left unmodified |
|
280 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
281 req.form[f.__regid__] = '1' |
|
282 f.add_rql_restrictions() |
|
283 # selection is cluttered because rqlst has been prepared for facet (it |
|
284 # is not in real life) |
|
285 self.assertEqual(f.select.as_string(), |
|
286 "DISTINCT Any WHERE X is CWUser, X created_by F, F owned_by G, G eid 1") |
|
287 |
|
288 def test_rql_path_eid_no_label(self): |
|
289 with self.admin_access.web_request() as req: |
|
290 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
291 class RPF(facet.RQLPathFacet): |
|
292 path = [('X created_by U'), ('U owned_by O'), ('O login OL')] |
|
293 filter_variable = 'O' |
|
294 f = RPF(req, rset=rset, select=rqlst.children[0], |
|
295 filtered_variable=filtered_variable) |
|
296 self.assertEqual(f.vocabulary(), [(str(req.user.eid), req.user.eid),]) |
|
297 |
|
298 def test_rql_path_attr(self): |
|
299 with self.admin_access.web_request() as req: |
|
300 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
301 class RPF(facet.RQLPathFacet): |
|
302 path = [('X created_by U'), ('U owned_by O'), ('O login OL')] |
|
303 filter_variable = 'OL' |
|
304 f = RPF(req, rset=rset, select=rqlst.children[0], |
|
305 filtered_variable=filtered_variable) |
|
306 |
|
307 self.assertEqual(f.vocabulary(), [(u'admin', 'admin'),]) |
|
308 # ensure rqlst is left unmodified |
|
309 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
310 self.assertEqual(f.possible_values(), ['admin',]) |
|
311 # ensure rqlst is left unmodified |
|
312 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
313 req.form[f.__regid__] = u'admin' |
|
314 f.add_rql_restrictions() |
|
315 # selection is cluttered because rqlst has been prepared for facet (it |
|
316 # is not in real life) |
|
317 self.assertEqual(f.select.as_string(), |
|
318 'DISTINCT Any WHERE X is CWUser, X created_by G, G owned_by H, H login "admin"') |
|
319 |
|
320 def test_rql_path_check_filter_label_variable(self): |
|
321 with self.admin_access.web_request() as req: |
|
322 rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req) |
|
323 class RPF(facet.RQLPathFacet): |
|
324 path = [('X created_by U'), ('U owned_by O'), ('O login OL')] |
|
325 filter_variable = 'OL' |
|
326 label_variable = 'OL' |
|
327 self.assertRaises(AssertionError, RPF, req, rset=rset, |
|
328 select=rqlst.children[0], |
|
329 filtered_variable=filtered_variable) |
|
330 |
|
331 |
|
332 def test_rqlpath_range(self): |
|
333 with self.admin_access.web_request() as req: |
|
334 rset, rqlst, filtered_variable = self.prepare_rqlst(req) |
|
335 class RRF(facet.DateRangeRQLPathFacet): |
|
336 path = [('X created_by U'), ('U owned_by O'), ('O creation_date OL')] |
|
337 filter_variable = 'OL' |
|
338 f = RRF(req, rset=rset, select=rqlst.children[0], |
|
339 filtered_variable=filtered_variable) |
|
340 mind, maxd = req.cnx.execute('Any MIN(CD), MAX(CD) WHERE X is CWUser, X created_by U, U owned_by O, O creation_date CD')[0] |
|
341 self.assertEqual(f.vocabulary(), [(str(mind), mind), |
|
342 (str(maxd), maxd)]) |
|
343 # ensure rqlst is left unmodified |
|
344 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
345 self.assertEqual(f.possible_values(), |
|
346 [str(mind), str(maxd)]) |
|
347 # ensure rqlst is left unmodified |
|
348 self.assertEqual(rqlst.as_string(), 'DISTINCT Any WHERE X is CWUser') |
|
349 req.form['%s_inf' % f.__regid__] = str(datetime2ticks(mind)) |
|
350 req.form['%s_sup' % f.__regid__] = str(datetime2ticks(mind)) |
|
351 f.add_rql_restrictions() |
|
352 # selection is cluttered because rqlst has been prepared for facet (it |
|
353 # is not in real life) |
|
354 self.assertEqual(f.select.as_string(), |
|
355 'DISTINCT Any WHERE X is CWUser, X created_by G, G owned_by H, H creation_date >= "%s", ' |
|
356 'H creation_date <= "%s"' |
|
357 % (mind.strftime('%Y/%m/%d'), |
|
358 mind.strftime('%Y/%m/%d'))) |
|
359 |
|
360 def prepareg_aggregat_rqlst(self, req): |
|
361 return self.prepare_rqlst(req, |
|
362 u'Any 1, COUNT(X) WHERE X is CWUser, X creation_date XD, ' |
|
363 'X modification_date XM, Y creation_date YD, Y is CWGroup ' |
|
364 'HAVING DAY(XD)>=DAY(YD) AND DAY(XM)<=DAY(YD)', 'X', |
|
365 expected_baserql=u'Any 1,COUNT(X) WHERE X is CWUser, X creation_date XD, ' |
|
366 'X modification_date XM, Y creation_date YD, Y is CWGroup ' |
|
367 'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)', |
|
368 expected_preparedrql=u'DISTINCT Any WHERE X is CWUser, X creation_date XD, ' |
|
369 'X modification_date XM, Y creation_date YD, Y is CWGroup ' |
|
370 'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)') |
|
371 |
|
372 |
|
373 def test_aggregat_query_cleanup_select(self): |
|
374 with self.admin_access.web_request() as req: |
|
375 rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req) |
|
376 select = rqlst.children[0] |
|
377 facet.cleanup_select(select, filtered_variable=filtered_variable) |
|
378 self.assertEqual(select.as_string(), |
|
379 'DISTINCT Any WHERE X is CWUser, X creation_date XD, ' |
|
380 'X modification_date XM, Y creation_date YD, Y is CWGroup ' |
|
381 'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)') |
|
382 |
|
383 def test_aggregat_query_rql_path(self): |
|
384 with self.admin_access.web_request() as req: |
|
385 rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req) |
|
386 class RPF(facet.RQLPathFacet): |
|
387 path = [('X created_by U'), ('U owned_by O'), ('O login OL')] |
|
388 filter_variable = 'OL' |
|
389 f = RPF(req, rset=rset, select=rqlst.children[0], |
|
390 filtered_variable=filtered_variable) |
|
391 self.assertEqual(f.vocabulary(), [(u'admin', u'admin')]) |
|
392 self.assertEqual(f.possible_values(), ['admin']) |
|
393 req.form[f.__regid__] = u'admin' |
|
394 f.add_rql_restrictions() |
|
395 self.assertEqual(f.select.as_string(), |
|
396 'DISTINCT Any WHERE X is CWUser, X creation_date XD, ' |
|
397 'X modification_date XM, Y creation_date YD, Y is CWGroup, ' |
|
398 'X created_by G, G owned_by H, H login "admin" ' |
|
399 'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)') |
|
400 |
|
401 def test_aggregat_query_attribute(self): |
|
402 with self.admin_access.web_request() as req: |
|
403 rset, rqlst, filtered_variable = self.prepareg_aggregat_rqlst(req) |
|
404 f = facet.AttributeFacet(req, rset=rset, |
|
405 select=rqlst.children[0], |
|
406 filtered_variable=filtered_variable) |
|
407 f.rtype = 'login' |
|
408 self.assertEqual(f.vocabulary(), |
|
409 [(u'admin', u'admin'), (u'anon', u'anon')]) |
|
410 self.assertEqual(f.possible_values(), |
|
411 ['admin', 'anon']) |
|
412 req.form[f.__regid__] = u'admin' |
|
413 f.add_rql_restrictions() |
|
414 self.assertEqual(f.select.as_string(), |
|
415 'DISTINCT Any WHERE X is CWUser, X creation_date XD, ' |
|
416 'X modification_date XM, Y creation_date YD, Y is CWGroup, X login "admin" ' |
|
417 'HAVING DAY(XD) >= DAY(YD), DAY(XM) <= DAY(YD)') |
|
418 |
|
419 if __name__ == '__main__': |
|
420 from logilab.common.testlib import unittest_main |
|
421 unittest_main() |
|