author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Thu, 17 Jun 2010 18:36:16 +0200 | |
branch | stable |
changeset 5782 | 8ff48d1a319f |
parent 5701 | 41119f034735 |
child 5811 | e77cea9721e7 |
permissions | -rw-r--r-- |
0 | 1 |
# -*- coding: iso-8859-1 -*- |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
2 |
# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
3 |
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
4 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
5 |
# This file is part of CubicWeb. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
6 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
7 |
# CubicWeb is free software: you can redistribute it and/or modify it under the |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
8 |
# terms of the GNU Lesser General Public License as published by the Free |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
9 |
# Software Foundation, either version 2.1 of the License, or (at your option) |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
10 |
# any later version. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
11 |
# |
5424
8ecbcbff9777
replace logilab-common by CubicWeb in disclaimer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5421
diff
changeset
|
12 |
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
13 |
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
14 |
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
15 |
# details. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
16 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
17 |
# You should have received a copy of the GNU Lesser General Public License along |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
18 |
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>. |
0 | 19 |
"""unit tests for modules cubicweb.server.querier and cubicweb.server.querier_steps |
20 |
""" |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
21 |
from datetime import date, datetime |
0 | 22 |
|
23 |
from logilab.common.testlib import TestCase, unittest_main |
|
24 |
from rql import BadRQLQuery, RQLSyntaxError |
|
1251
af40e615dc89
introduce a 'cw_' prefix on entity table and column names so we don't conflict with sql or DBMS specific keywords
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
25 |
|
1949
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
26 |
from cubicweb import QueryError, Unauthorized, Binary |
1251
af40e615dc89
introduce a 'cw_' prefix on entity table and column names so we don't conflict with sql or DBMS specific keywords
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
27 |
from cubicweb.server.sqlutils import SQL_PREFIX |
0 | 28 |
from cubicweb.server.utils import crypt_password |
29 |
from cubicweb.server.sources.native import make_schema |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
30 |
from cubicweb.devtools import init_test_database |
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
31 |
from cubicweb.devtools.repotest import tuplify, BaseQuerierTC |
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
32 |
|
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
33 |
from unittest_session import Variable |
0 | 34 |
|
35 |
||
36 |
# register priority/severity sorting registered procedure |
|
37 |
from rql.utils import register_function, FunctionDescr |
|
38 |
||
39 |
class group_sort_value(FunctionDescr): |
|
40 |
supported_backends = ('sqlite',) |
|
41 |
rtype = 'Int' |
|
42 |
try: |
|
43 |
register_function(group_sort_value) |
|
44 |
except AssertionError: |
|
45 |
pass |
|
46 |
from cubicweb.server.sqlutils import SQL_CONNECT_HOOKS |
|
47 |
def init_sqlite_connexion(cnx): |
|
48 |
def group_sort_value(text): |
|
49 |
return {"managers": "3", "users": "2", "guests": "1", "owners": "0"}[text] |
|
50 |
cnx.create_function("GROUP_SORT_VALUE", 1, group_sort_value) |
|
51 |
SQL_CONNECT_HOOKS['sqlite'].append(init_sqlite_connexion) |
|
52 |
||
53 |
||
4848
41f84eea63c9
rename logilab.db into logilab.database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4831
diff
changeset
|
54 |
from logilab.database import _GenericAdvFuncHelper |
0 | 55 |
TYPEMAP = _GenericAdvFuncHelper.TYPE_MAPPING |
56 |
||
57 |
class MakeSchemaTC(TestCase): |
|
58 |
def test_known_values(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
59 |
solution = {'A': 'String', 'B': 'CWUser'} |
1787 | 60 |
self.assertEquals(make_schema((Variable('A'), Variable('B')), solution, |
0 | 61 |
'table0', TYPEMAP), |
62 |
('C0 text,C1 integer', {'A': 'table0.C0', 'B': 'table0.C1'})) |
|
1787 | 63 |
|
0 | 64 |
|
2773
b2530e3e0afb
[testlib] #345052 and #344207: major test lib refactoring/cleanup + update usage
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
65 |
repo, cnx = init_test_database() |
0 | 66 |
|
4766
162b2b127b15
[test] get a chance to get proper garbage collection when running pytest on whole cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4758
diff
changeset
|
67 |
def teardown_module(*args): |
162b2b127b15
[test] get a chance to get proper garbage collection when running pytest on whole cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4758
diff
changeset
|
68 |
global repo, cnx |
162b2b127b15
[test] get a chance to get proper garbage collection when running pytest on whole cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4758
diff
changeset
|
69 |
cnx.close() |
162b2b127b15
[test] get a chance to get proper garbage collection when running pytest on whole cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4758
diff
changeset
|
70 |
repo.shutdown() |
162b2b127b15
[test] get a chance to get proper garbage collection when running pytest on whole cw
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4758
diff
changeset
|
71 |
del repo, cnx |
0 | 72 |
|
73 |
||
74 |
class UtilsTC(BaseQuerierTC): |
|
75 |
repo = repo |
|
1787 | 76 |
|
0 | 77 |
def get_max_eid(self): |
78 |
# no need for cleanup here |
|
79 |
return None |
|
80 |
def cleanup(self): |
|
81 |
# no need for cleanup here |
|
82 |
pass |
|
1787 | 83 |
|
0 | 84 |
def test_preprocess_1(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
85 |
reid = self.execute('Any X WHERE X is CWRType, X name "owned_by"')[0][0] |
0 | 86 |
rqlst = self._prepare('Any COUNT(RDEF) WHERE RDEF relation_type X, X eid %(x)s', {'x': reid}) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
87 |
self.assertEquals(rqlst.solutions, [{'RDEF': 'CWAttribute'}, {'RDEF': 'CWRelation'}]) |
1787 | 88 |
|
0 | 89 |
def test_preprocess_2(self): |
90 |
teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
91 |
#geid = self.execute("CWGroup G WHERE G name 'users'")[0][0] |
0 | 92 |
#self.execute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
93 |
# {'g': geid, 't': teid}, 'g') |
|
94 |
rqlst = self._prepare('Any X WHERE E eid %(x)s, E tags X', {'x': teid}) |
|
95 |
# the query may be optimized, should keep only one solution |
|
96 |
# (any one, etype will be discarded) |
|
97 |
self.assertEquals(len(rqlst.solutions), 1) |
|
1787 | 98 |
|
0 | 99 |
def test_preprocess_security(self): |
100 |
plan = self._prepare_plan('Any ETN,COUNT(X) GROUPBY ETN ' |
|
101 |
'WHERE X is ET, ET name ETN') |
|
4674
3d509dbb473a
[test api] rename _user_session to user_groups_session, fix its arguments and return only the session, not (user, session) to make things clearer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4467
diff
changeset
|
102 |
plan.session = self.user_groups_session('users') |
0 | 103 |
union = plan.rqlst |
104 |
plan.preprocess(union) |
|
105 |
self.assertEquals(len(union.children), 1) |
|
106 |
self.assertEquals(len(union.children[0].with_), 1) |
|
107 |
subq = union.children[0].with_[0].query |
|
108 |
self.assertEquals(len(subq.children), 3) |
|
109 |
self.assertEquals([t.as_string() for t in union.children[0].selection], |
|
110 |
['ETN','COUNT(X)']) |
|
111 |
self.assertEquals([t.as_string() for t in union.children[0].groupby], |
|
112 |
['ETN']) |
|
113 |
partrqls = sorted(((rqlst.as_string(), rqlst.solutions) for rqlst in subq.children)) |
|
114 |
rql, solutions = partrqls[0] |
|
115 |
self.assertEquals(rql, |
|
116 |
'Any ETN,X WHERE X is ET, ET name ETN, (EXISTS(X owned_by %(B)s))' |
|
117 |
' OR ((((EXISTS(D concerne C?, C owned_by %(B)s, X identity D, C is Division, D is Affaire))' |
|
118 |
' OR (EXISTS(H concerne G?, G owned_by %(B)s, G is SubDivision, X identity H, H is Affaire)))' |
|
119 |
' OR (EXISTS(I concerne F?, F owned_by %(B)s, F is Societe, X identity I, I is Affaire)))' |
|
120 |
' OR (EXISTS(J concerne E?, E owned_by %(B)s, E is Note, X identity J, J is Affaire)))' |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
121 |
', ET is CWEType, X is Affaire') |
0 | 122 |
self.assertEquals(solutions, [{'C': 'Division', |
123 |
'D': 'Affaire', |
|
124 |
'E': 'Note', |
|
125 |
'F': 'Societe', |
|
126 |
'G': 'SubDivision', |
|
127 |
'H': 'Affaire', |
|
128 |
'I': 'Affaire', |
|
129 |
'J': 'Affaire', |
|
130 |
'X': 'Affaire', |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
131 |
'ET': 'CWEType', 'ETN': 'String'}]) |
0 | 132 |
rql, solutions = partrqls[1] |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
133 |
self.assertEquals(rql, 'Any ETN,X WHERE X is ET, ET name ETN, ET is CWEType, X is IN(BaseTransition, Bookmark, CWAttribute, CWCache, CWConstraint, CWConstraintType, CWEType, CWGroup, CWPermission, CWProperty, CWRType, CWRelation, CWUser, Card, Comment, Division, Email, EmailAddress, EmailPart, EmailThread, ExternalUri, File, Folder, Image, Note, Personne, RQLExpression, Societe, State, SubDivision, SubWorkflowExitPoint, Tag, TrInfo, Transition, Workflow, WorkflowTransition)') |
0 | 134 |
self.assertListEquals(sorted(solutions), |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
135 |
sorted([{'X': 'BaseTransition', 'ETN': 'String', 'ET': 'CWEType'}, |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
136 |
{'X': 'Bookmark', 'ETN': 'String', 'ET': 'CWEType'}, |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
137 |
{'X': 'Card', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
138 |
{'X': 'Comment', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
139 |
{'X': 'Division', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
140 |
{'X': 'CWCache', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
141 |
{'X': 'CWConstraint', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
142 |
{'X': 'CWConstraintType', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
143 |
{'X': 'CWEType', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
144 |
{'X': 'CWAttribute', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
145 |
{'X': 'CWGroup', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
146 |
{'X': 'Email', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
147 |
{'X': 'EmailAddress', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
148 |
{'X': 'EmailPart', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
149 |
{'X': 'EmailThread', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
150 |
{'X': 'CWRelation', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
151 |
{'X': 'CWPermission', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
152 |
{'X': 'CWProperty', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
153 |
{'X': 'CWRType', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
154 |
{'X': 'CWUser', 'ETN': 'String', 'ET': 'CWEType'}, |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
155 |
{'X': 'ExternalUri', 'ETN': 'String', 'ET': 'CWEType'}, |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
156 |
{'X': 'File', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
157 |
{'X': 'Folder', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
158 |
{'X': 'Image', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
159 |
{'X': 'Note', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
160 |
{'X': 'Personne', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
161 |
{'X': 'RQLExpression', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
162 |
{'X': 'Societe', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
163 |
{'X': 'State', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
164 |
{'X': 'SubDivision', 'ETN': 'String', 'ET': 'CWEType'}, |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
165 |
{'X': 'SubWorkflowExitPoint', 'ETN': 'String', 'ET': 'CWEType'}, |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
166 |
{'X': 'Tag', 'ETN': 'String', 'ET': 'CWEType'}, |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
167 |
{'X': 'Transition', 'ETN': 'String', 'ET': 'CWEType'}, |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
168 |
{'X': 'TrInfo', 'ETN': 'String', 'ET': 'CWEType'}, |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
169 |
{'X': 'Workflow', 'ETN': 'String', 'ET': 'CWEType'}, |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
170 |
{'X': 'WorkflowTransition', 'ETN': 'String', 'ET': 'CWEType'}])) |
0 | 171 |
rql, solutions = partrqls[2] |
172 |
self.assertEquals(rql, |
|
173 |
'Any ETN,X WHERE X is ET, ET name ETN, EXISTS(X owned_by %(C)s), ' |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
174 |
'ET is CWEType, X is Basket') |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
175 |
self.assertEquals(solutions, [{'ET': 'CWEType', |
0 | 176 |
'X': 'Basket', |
177 |
'ETN': 'String', |
|
178 |
}]) |
|
179 |
||
180 |
def test_preprocess_security_aggregat(self): |
|
181 |
plan = self._prepare_plan('Any MAX(X)') |
|
4674
3d509dbb473a
[test api] rename _user_session to user_groups_session, fix its arguments and return only the session, not (user, session) to make things clearer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4467
diff
changeset
|
182 |
plan.session = self.user_groups_session('users') |
0 | 183 |
union = plan.rqlst |
184 |
plan.preprocess(union) |
|
185 |
self.assertEquals(len(union.children), 1) |
|
186 |
self.assertEquals(len(union.children[0].with_), 1) |
|
187 |
subq = union.children[0].with_[0].query |
|
188 |
self.assertEquals(len(subq.children), 3) |
|
189 |
self.assertEquals([t.as_string() for t in union.children[0].selection], |
|
190 |
['MAX(X)']) |
|
1787 | 191 |
|
0 | 192 |
def test_preprocess_nonregr(self): |
193 |
rqlst = self._prepare('Any S ORDERBY SI WHERE NOT S ecrit_par O, S para SI') |
|
194 |
self.assertEquals(len(rqlst.solutions), 1) |
|
1787 | 195 |
|
0 | 196 |
def test_build_description(self): |
197 |
# should return an empty result set |
|
198 |
rset = self.execute('Any X WHERE X eid %(x)s', {'x': self.session.user.eid}) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
199 |
self.assertEquals(rset.description[0][0], 'CWUser') |
0 | 200 |
rset = self.execute('Any 1') |
201 |
self.assertEquals(rset.description[0][0], 'Int') |
|
202 |
rset = self.execute('Any TRUE') |
|
203 |
self.assertEquals(rset.description[0][0], 'Boolean') |
|
204 |
rset = self.execute('Any "hop"') |
|
205 |
self.assertEquals(rset.description[0][0], 'String') |
|
206 |
rset = self.execute('Any TODAY') |
|
207 |
self.assertEquals(rset.description[0][0], 'Date') |
|
208 |
rset = self.execute('Any NOW') |
|
209 |
self.assertEquals(rset.description[0][0], 'Datetime') |
|
210 |
rset = self.execute('Any %(x)s', {'x': 1}) |
|
211 |
self.assertEquals(rset.description[0][0], 'Int') |
|
212 |
rset = self.execute('Any %(x)s', {'x': 1L}) |
|
213 |
self.assertEquals(rset.description[0][0], 'Int') |
|
214 |
rset = self.execute('Any %(x)s', {'x': True}) |
|
215 |
self.assertEquals(rset.description[0][0], 'Boolean') |
|
216 |
rset = self.execute('Any %(x)s', {'x': 1.0}) |
|
217 |
self.assertEquals(rset.description[0][0], 'Float') |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
218 |
rset = self.execute('Any %(x)s', {'x': datetime.now()}) |
0 | 219 |
self.assertEquals(rset.description[0][0], 'Datetime') |
220 |
rset = self.execute('Any %(x)s', {'x': 'str'}) |
|
221 |
self.assertEquals(rset.description[0][0], 'String') |
|
222 |
rset = self.execute('Any %(x)s', {'x': u'str'}) |
|
223 |
self.assertEquals(rset.description[0][0], 'String') |
|
224 |
||
225 |
||
226 |
class QuerierTC(BaseQuerierTC): |
|
227 |
repo = repo |
|
228 |
||
229 |
def test_encoding_pb(self): |
|
230 |
self.assertRaises(RQLSyntaxError, self.execute, |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
231 |
'Any X WHERE X is CWRType, X name "�wned_by"') |
0 | 232 |
|
233 |
def test_unknown_eid(self): |
|
234 |
# should return an empty result set |
|
235 |
self.failIf(self.execute('Any X WHERE X eid 99999999')) |
|
1787 | 236 |
|
3109
e7e1bb06b716
ensure eid given in arguments will be returned correctly typed (though only if they are in the cachekey for now)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
237 |
def test_typed_eid(self): |
e7e1bb06b716
ensure eid given in arguments will be returned correctly typed (though only if they are in the cachekey for now)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
238 |
# should return an empty result set |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
239 |
rset = self.execute('Any X WHERE X eid %(x)s', {'x': '1'}) |
3109
e7e1bb06b716
ensure eid given in arguments will be returned correctly typed (though only if they are in the cachekey for now)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
240 |
self.assertIsInstance(rset[0][0], (int, long)) |
e7e1bb06b716
ensure eid given in arguments will be returned correctly typed (though only if they are in the cachekey for now)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
241 |
|
1949
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
242 |
def test_bytes_storage(self): |
3587 | 243 |
feid = self.execute('INSERT File X: X data_name "foo.pdf", X data_format "text/plain", X data %(data)s', |
1949
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
244 |
{'data': Binary("xxx")})[0][0] |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
245 |
fdata = self.execute('Any D WHERE X data D, X eid %(x)s', {'x': feid})[0][0] |
1949
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
246 |
self.assertIsInstance(fdata, Binary) |
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
247 |
self.assertEquals(fdata.getvalue(), 'xxx') |
9064102b4deb
test Bytes storage/retreival
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1787
diff
changeset
|
248 |
|
0 | 249 |
# selection queries tests ################################################# |
1787 | 250 |
|
0 | 251 |
def test_select_1(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
252 |
rset = self.execute('Any X ORDERBY X WHERE X is CWGroup') |
0 | 253 |
result, descr = rset.rows, rset.description |
254 |
self.assertEquals(tuplify(result), [(1,), (2,), (3,), (4,)]) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
255 |
self.assertEquals(descr, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
1787 | 256 |
|
0 | 257 |
def test_select_2(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
258 |
rset = self.execute('Any X ORDERBY N WHERE X is CWGroup, X name N') |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
259 |
self.assertEquals(tuplify(rset.rows), [(1,), (2,), (3,), (4,)]) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
260 |
self.assertEquals(rset.description, [('CWGroup',), ('CWGroup',), ('CWGroup',), ('CWGroup',)]) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
261 |
rset = self.execute('Any X ORDERBY N DESC WHERE X is CWGroup, X name N') |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
262 |
self.assertEquals(tuplify(rset.rows), [(4,), (3,), (2,), (1,)]) |
1787 | 263 |
|
0 | 264 |
def test_select_3(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
265 |
rset = self.execute('Any N GROUPBY N WHERE X is CWGroup, X name N') |
0 | 266 |
result, descr = rset.rows, rset.description |
267 |
result.sort() |
|
268 |
self.assertEquals(tuplify(result), [('guests',), ('managers',), ('owners',), ('users',)]) |
|
269 |
self.assertEquals(descr, [('String',), ('String',), ('String',), ('String',)]) |
|
1787 | 270 |
|
0 | 271 |
def test_select_is(self): |
272 |
rset = self.execute('Any X, TN ORDERBY TN LIMIT 10 WHERE X is T, T name TN') |
|
273 |
result, descr = rset.rows, rset.description |
|
274 |
self.assertEquals(result[0][1], descr[0][0]) |
|
1787 | 275 |
|
0 | 276 |
def test_select_is_aggr(self): |
277 |
rset = self.execute('Any TN, COUNT(X) GROUPBY TN ORDERBY 2 DESC WHERE X is T, T name TN') |
|
278 |
result, descr = rset.rows, rset.description |
|
279 |
self.assertEquals(descr[0][0], 'String') |
|
280 |
self.assertEquals(descr[0][1], 'Int') |
|
4758
0efdcf0fa4c7
fix code and tests broken by 4744:13a5d3a7410e (proper permission on eid/has_text/identity relations)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4680
diff
changeset
|
281 |
self.assertEquals(result[0][0], 'CWRelation') # XXX may change as schema evolve |
1787 | 282 |
|
0 | 283 |
def test_select_groupby_orderby(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
284 |
rset = self.execute('Any N GROUPBY N ORDERBY N WHERE X is CWGroup, X name N') |
0 | 285 |
self.assertEquals(tuplify(rset.rows), [('guests',), ('managers',), ('owners',), ('users',)]) |
286 |
self.assertEquals(rset.description, [('String',), ('String',), ('String',), ('String',)]) |
|
1787 | 287 |
|
0 | 288 |
def test_select_complex_groupby(self): |
289 |
rset = self.execute('Any N GROUPBY N WHERE X name N') |
|
290 |
rset = self.execute('Any N,MAX(D) GROUPBY N LIMIT 5 WHERE X name N, X creation_date D') |
|
1787 | 291 |
|
0 | 292 |
def test_select_inlined_groupby(self): |
293 |
seid = self.execute('State X WHERE X name "deactivated"')[0][0] |
|
294 |
rset = self.execute('Any U,L,S GROUPBY U,L,S WHERE X in_state S, U login L, S eid %s' % seid) |
|
1787 | 295 |
|
0 | 296 |
def test_select_complex_orderby(self): |
297 |
rset1 = self.execute('Any N ORDERBY N WHERE X name N') |
|
298 |
self.assertEquals(sorted(rset1.rows), rset1.rows) |
|
299 |
rset = self.execute('Any N ORDERBY N LIMIT 5 OFFSET 1 WHERE X name N') |
|
1787 | 300 |
self.assertEquals(rset.rows[0][0], rset1.rows[1][0]) |
0 | 301 |
self.assertEquals(len(rset), 5) |
1787 | 302 |
|
0 | 303 |
def test_select_5(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
304 |
rset = self.execute('Any X, TMP ORDERBY TMP WHERE X name TMP, X is CWGroup') |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
305 |
self.assertEquals(tuplify(rset.rows), [(1, 'guests',), (2, 'managers',), (3, 'owners',), (4, 'users',)]) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
306 |
self.assertEquals(rset.description, [('CWGroup', 'String',), ('CWGroup', 'String',), ('CWGroup', 'String',), ('CWGroup', 'String',)]) |
1787 | 307 |
|
0 | 308 |
def test_select_6(self): |
309 |
self.execute("INSERT Personne X: X nom 'bidule'")[0] |
|
310 |
rset = self.execute('Any Y where X name TMP, Y nom in (TMP, "bidule")') |
|
311 |
#self.assertEquals(rset.description, [('Personne',), ('Personne',)]) |
|
312 |
self.assert_(('Personne',) in rset.description) |
|
313 |
rset = self.execute('DISTINCT Any Y where X name TMP, Y nom in (TMP, "bidule")') |
|
314 |
self.assert_(('Personne',) in rset.description) |
|
1787 | 315 |
|
0 | 316 |
def test_select_not_attr(self): |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
317 |
peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
318 |
seid = self.execute("INSERT Societe X: X nom 'chouette'")[0][0] |
0 | 319 |
rset = self.execute('Personne X WHERE NOT X nom "bidule"') |
320 |
self.assertEquals(len(rset.rows), 0, rset.rows) |
|
321 |
rset = self.execute('Personne X WHERE NOT X nom "bid"') |
|
322 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
323 |
self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
|
324 |
rset = self.execute('Personne X WHERE NOT X travaille S') |
|
325 |
self.assertEquals(len(rset.rows), 0, rset.rows) |
|
1787 | 326 |
|
0 | 327 |
def test_select_is_in(self): |
328 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
329 |
self.execute("INSERT Societe X: X nom 'chouette'") |
|
330 |
self.assertEquals(len(self.execute("Any X WHERE X is IN (Personne, Societe)")), |
|
331 |
2) |
|
1787 | 332 |
|
0 | 333 |
def test_select_not_rel(self): |
334 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
335 |
self.execute("INSERT Societe X: X nom 'chouette'") |
|
336 |
self.execute("INSERT Personne X: X nom 'autre'") |
|
337 |
self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
|
338 |
rset = self.execute('Personne X WHERE NOT X travaille S') |
|
339 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
340 |
rset = self.execute('Personne X WHERE NOT X travaille S, S nom "chouette"') |
|
341 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 342 |
|
0 | 343 |
def test_select_nonregr_inlined(self): |
344 |
self.execute("INSERT Note X: X para 'bidule'") |
|
345 |
self.execute("INSERT Personne X: X nom 'chouette'") |
|
346 |
self.execute("INSERT Personne X: X nom 'autre'") |
|
347 |
self.execute("SET X ecrit_par P WHERE X para 'bidule', P nom 'chouette'") |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
348 |
rset = self.execute('Any U,T ORDERBY T DESC WHERE U is CWUser, ' |
0 | 349 |
'N ecrit_par U, N type T')#, {'x': self.ueid}) |
350 |
self.assertEquals(len(rset.rows), 0) |
|
1787 | 351 |
|
0 | 352 |
def test_select_nonregr_edition_not(self): |
353 |
groupeids = set((1, 2, 3)) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
354 |
groupreadperms = set(r[0] for r in self.execute('Any Y WHERE X name "CWGroup", Y eid IN(1, 2, 3), X read_permission Y')) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
355 |
rset = self.execute('DISTINCT Any Y WHERE X is CWEType, X name "CWGroup", Y eid IN(1, 2, 3), NOT X read_permission Y') |
0 | 356 |
self.assertEquals(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
357 |
rset = self.execute('DISTINCT Any Y WHERE X name "CWGroup", Y eid IN(1, 2, 3), NOT X read_permission Y') |
0 | 358 |
self.assertEquals(sorted(r[0] for r in rset.rows), sorted(groupeids - groupreadperms)) |
1787 | 359 |
|
0 | 360 |
def test_select_outer_join(self): |
361 |
peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
362 |
peid2 = self.execute("INSERT Personne X: X nom 'autre'")[0][0] |
|
363 |
seid1 = self.execute("INSERT Societe X: X nom 'chouette'")[0][0] |
|
364 |
seid2 = self.execute("INSERT Societe X: X nom 'chouetos'")[0][0] |
|
365 |
rset = self.execute('Any X,S ORDERBY X WHERE X travaille S?') |
|
366 |
self.assertEquals(rset.rows, [[peid1, None], [peid2, None]]) |
|
367 |
self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'chouette'") |
|
368 |
rset = self.execute('Any X,S ORDERBY X WHERE X travaille S?') |
|
369 |
self.assertEquals(rset.rows, [[peid1, seid1], [peid2, None]]) |
|
370 |
rset = self.execute('Any S,X ORDERBY S WHERE X? travaille S') |
|
371 |
self.assertEquals(rset.rows, [[seid1, peid1], [seid2, None]]) |
|
1787 | 372 |
|
0 | 373 |
def test_select_outer_join_optimized(self): |
374 |
peid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
375 |
rset = self.execute('Any X WHERE X eid %(x)s, P? connait X', {'x':peid1}) |
0 | 376 |
self.assertEquals(rset.rows, [[peid1]]) |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
377 |
rset = self.execute('Any X WHERE X eid %(x)s, X require_permission P?', |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
378 |
{'x':peid1}) |
0 | 379 |
self.assertEquals(rset.rows, [[peid1]]) |
380 |
||
381 |
def test_select_left_outer_join(self): |
|
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
382 |
rset = self.execute('DISTINCT Any G WHERE U? in_group G') |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
383 |
self.assertEquals(len(rset), 4) |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
384 |
rset = self.execute('DISTINCT Any G WHERE U? in_group G, U eid %(x)s', |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
385 |
{'x': self.session.user.eid}) |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
386 |
self.assertEquals(len(rset), 4) |
0 | 387 |
|
388 |
def test_select_ambigous_outer_join(self): |
|
389 |
teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
|
390 |
self.execute("INSERT Tag X: X name 'tagbis'")[0][0] |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
391 |
geid = self.execute("CWGroup G WHERE G name 'users'")[0][0] |
0 | 392 |
self.execute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
393 |
{'g': geid, 't': teid}) |
0 | 394 |
rset = self.execute("Any GN,TN ORDERBY GN WHERE T? tags G, T name TN, G name GN") |
395 |
self.failUnless(['users', 'tag'] in rset.rows) |
|
396 |
self.failUnless(['activated', None] in rset.rows) |
|
397 |
rset = self.execute("Any GN,TN ORDERBY GN WHERE T tags G?, T name TN, G name GN") |
|
1787 | 398 |
self.assertEquals(rset.rows, [[None, 'tagbis'], ['users', 'tag']]) |
399 |
||
0 | 400 |
def test_select_not_inline_rel(self): |
401 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
402 |
self.execute("INSERT Note X: X type 'a'") |
|
403 |
self.execute("INSERT Note X: X type 'b'") |
|
404 |
self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
|
405 |
rset = self.execute('Note X WHERE NOT X ecrit_par P') |
|
406 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 407 |
|
0 | 408 |
def test_select_not_unlinked_multiple_solutions(self): |
409 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
410 |
self.execute("INSERT Note X: X type 'a'") |
|
411 |
self.execute("INSERT Note X: X type 'b'") |
|
412 |
self.execute("SET Y evaluee X WHERE X type 'a', Y nom 'bidule'") |
|
413 |
rset = self.execute('Note X WHERE NOT Y evaluee X') |
|
414 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
415 |
||
4831
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
416 |
def test_select_date_extraction(self): |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
417 |
self.execute("INSERT Personne X: X nom 'foo', X datenaiss %(d)s", |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
418 |
{'d': datetime(2001, 2,3, 12,13)}) |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
419 |
test_data = [('YEAR', 2001), ('MONTH', 2), ('DAY', 3), |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
420 |
('HOUR', 12), ('MINUTE', 13)] |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
421 |
for funcname, result in test_data: |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
422 |
rset = self.execute('Any %s(D) WHERE X is Personne, X datenaiss D' |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
423 |
% funcname) |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
424 |
self.assertEquals(len(rset.rows), 1) |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
425 |
self.assertEquals(rset.rows[0][0], result) |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
426 |
self.assertEquals(rset.description, [('Int',)]) |
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
427 |
|
0 | 428 |
def test_select_aggregat_count(self): |
429 |
rset = self.execute('Any COUNT(X)') |
|
430 |
self.assertEquals(len(rset.rows), 1) |
|
431 |
self.assertEquals(len(rset.rows[0]), 1) |
|
432 |
self.assertEquals(rset.description, [('Int',)]) |
|
1787 | 433 |
|
0 | 434 |
def test_select_aggregat_sum(self): |
435 |
rset = self.execute('Any SUM(O) WHERE X ordernum O') |
|
436 |
self.assertEquals(len(rset.rows), 1) |
|
437 |
self.assertEquals(len(rset.rows[0]), 1) |
|
438 |
self.assertEquals(rset.description, [('Int',)]) |
|
1787 | 439 |
|
0 | 440 |
def test_select_aggregat_min(self): |
441 |
rset = self.execute('Any MIN(X) WHERE X is Personne') |
|
442 |
self.assertEquals(len(rset.rows), 1) |
|
443 |
self.assertEquals(len(rset.rows[0]), 1) |
|
444 |
self.assertEquals(rset.description, [('Personne',)]) |
|
445 |
rset = self.execute('Any MIN(O) WHERE X ordernum O') |
|
446 |
self.assertEquals(len(rset.rows), 1) |
|
447 |
self.assertEquals(len(rset.rows[0]), 1) |
|
448 |
self.assertEquals(rset.description, [('Int',)]) |
|
1787 | 449 |
|
0 | 450 |
def test_select_aggregat_max(self): |
451 |
rset = self.execute('Any MAX(X) WHERE X is Personne') |
|
452 |
self.assertEquals(len(rset.rows), 1) |
|
453 |
self.assertEquals(len(rset.rows[0]), 1) |
|
454 |
self.assertEquals(rset.description, [('Personne',)]) |
|
455 |
rset = self.execute('Any MAX(O) WHERE X ordernum O') |
|
456 |
self.assertEquals(len(rset.rows), 1) |
|
457 |
self.assertEquals(len(rset.rows[0]), 1) |
|
458 |
self.assertEquals(rset.description, [('Int',)]) |
|
459 |
||
460 |
def test_select_custom_aggregat_concat_string(self): |
|
4831
c5aec27c1bf7
[repo] use logilab.db instead of lgc.adbh/lgc.db/lgc.sqlgen/indexer, test new date extranction functions
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4795
diff
changeset
|
461 |
rset = self.execute('Any GROUP_CONCAT(N) WHERE X is CWGroup, X name N') |
0 | 462 |
self.failUnless(rset) |
463 |
self.failUnlessEqual(sorted(rset[0][0].split(', ')), ['guests', 'managers', |
|
464 |
'owners', 'users']) |
|
465 |
||
466 |
def test_select_custom_regproc_limit_size(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
467 |
rset = self.execute('Any TEXT_LIMIT_SIZE(N, 3) WHERE X is CWGroup, X name N, X name "managers"') |
0 | 468 |
self.failUnless(rset) |
469 |
self.failUnlessEqual(rset[0][0], 'man...') |
|
470 |
self.execute("INSERT Basket X: X name 'bidule', X description '<b>hop hop</b>', X description_format 'text/html'") |
|
471 |
rset = self.execute('Any LIMIT_SIZE(D, DF, 3) WHERE X is Basket, X description D, X description_format DF') |
|
472 |
self.failUnless(rset) |
|
473 |
self.failUnlessEqual(rset[0][0], 'hop...') |
|
474 |
||
475 |
def test_select_regproc_orderby(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
476 |
rset = self.execute('DISTINCT Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, X name "managers"') |
0 | 477 |
self.failUnlessEqual(len(rset), 1) |
478 |
self.failUnlessEqual(rset[0][1], 'managers') |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
479 |
rset = self.execute('Any X,N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N, NOT U in_group X, U login "admin"') |
0 | 480 |
self.failUnlessEqual(len(rset), 3) |
481 |
self.failUnlessEqual(rset[0][1], 'owners') |
|
1787 | 482 |
|
0 | 483 |
def test_select_aggregat_sort(self): |
484 |
rset = self.execute('Any G, COUNT(U) GROUPBY G ORDERBY 2 WHERE U in_group G') |
|
485 |
self.assertEquals(len(rset.rows), 2) |
|
486 |
self.assertEquals(len(rset.rows[0]), 2) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
487 |
self.assertEquals(rset.description[0], ('CWGroup', 'Int',)) |
0 | 488 |
|
489 |
def test_select_aggregat_having(self): |
|
490 |
rset = self.execute('Any N,COUNT(RDEF) GROUPBY N ORDERBY 2,N ' |
|
491 |
'WHERE RT name N, RDEF relation_type RT ' |
|
492 |
'HAVING COUNT(RDEF) > 10') |
|
493 |
self.assertListEquals(rset.rows, |
|
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
494 |
[[u'description_format', 13], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
495 |
[u'description', 14], |
3587 | 496 |
[u'name', 14], |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
497 |
[u'created_by', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
498 |
[u'creation_date', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
499 |
[u'cwuri', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
500 |
[u'in_basket', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
501 |
[u'is', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
502 |
[u'is_instance_of', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
503 |
[u'modification_date', 38], |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
504 |
[u'owned_by', 38]]) |
0 | 505 |
|
506 |
def test_select_aggregat_having_dumb(self): |
|
507 |
# dumb but should not raise an error |
|
508 |
rset = self.execute('Any U,COUNT(X) GROUPBY U ' |
|
509 |
'WHERE U eid %(x)s, X owned_by U ' |
|
510 |
'HAVING COUNT(X) > 10', {'x': self.ueid}) |
|
511 |
self.assertEquals(len(rset.rows), 1) |
|
512 |
self.assertEquals(rset.rows[0][0], self.ueid) |
|
513 |
||
5782
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
514 |
def test_select_having_non_aggregat_1(self): |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
515 |
rset = self.execute('Any L WHERE X login L, X creation_date CD ' |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
516 |
'HAVING YEAR(CD) = %s' % date.today().year) |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
517 |
self.assertListEquals(rset.rows, |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
518 |
[[u'admin'], |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
519 |
[u'anon']]) |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
520 |
|
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
521 |
def test_select_having_non_aggregat_2(self): |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
522 |
rset = self.execute('Any L GROUPBY L WHERE X login L, X in_group G, ' |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
523 |
'X creation_date CD HAVING YEAR(CD) = %s OR COUNT(G) > 1' |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
524 |
% date.today().year) |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
525 |
self.assertListEquals(rset.rows, |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
526 |
[[u'admin'], |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
527 |
[u'anon']]) |
8ff48d1a319f
[rql2sql] when using HAVING to by-pass rql limitation (not to filter on result of an aggregat function), we should emit SQL that doesn't use HAVING to avoid potential backend error because variables are not grouped. Closes #1061603.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5701
diff
changeset
|
528 |
|
0 | 529 |
def test_select_complex_sort(self): |
1950
ab7a41b2cd26
reactivate skipped tests due to sqlite bug which is now fixed (sqlite 3.6.13)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1949
diff
changeset
|
530 |
"""need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix""" |
0 | 531 |
rset = self.execute('Any X ORDERBY X,D LIMIT 5 WHERE X creation_date D') |
532 |
result = rset.rows |
|
533 |
result.sort() |
|
534 |
self.assertEquals(tuplify(result), [(1,), (2,), (3,), (4,), (5,)]) |
|
1787 | 535 |
|
0 | 536 |
def test_select_upper(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
537 |
rset = self.execute('Any X, UPPER(L) ORDERBY L WHERE X is CWUser, X login L') |
0 | 538 |
self.assertEquals(len(rset.rows), 2) |
539 |
self.assertEquals(rset.rows[0][1], 'ADMIN') |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
540 |
self.assertEquals(rset.description[0], ('CWUser', 'String',)) |
0 | 541 |
self.assertEquals(rset.rows[1][1], 'ANON') |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
542 |
self.assertEquals(rset.description[1], ('CWUser', 'String',)) |
0 | 543 |
eid = rset.rows[0][0] |
544 |
rset = self.execute('Any UPPER(L) WHERE X eid %s, X login L'%eid) |
|
545 |
self.assertEquals(rset.rows[0][0], 'ADMIN') |
|
546 |
self.assertEquals(rset.description, [('String',)]) |
|
547 |
||
548 |
## def test_select_simplified(self): |
|
549 |
## ueid = self.session.user.eid |
|
550 |
## rset = self.execute('Any L WHERE %s login L'%ueid) |
|
551 |
## self.assertEquals(rset.rows[0][0], 'admin') |
|
552 |
## rset = self.execute('Any L WHERE %(x)s login L', {'x':ueid}) |
|
553 |
## self.assertEquals(rset.rows[0][0], 'admin') |
|
1787 | 554 |
|
0 | 555 |
def test_select_searchable_text_1(self): |
556 |
rset = self.execute(u"INSERT Personne X: X nom 'bid�le'") |
|
557 |
rset = self.execute(u"INSERT Societe X: X nom 'bid�le'") |
|
558 |
rset = self.execute("INSERT Societe X: X nom 'chouette'") |
|
559 |
self.commit() |
|
560 |
rset = self.execute('Any X where X has_text %(text)s', {'text': u'bid�le'}) |
|
561 |
self.assertEquals(len(rset.rows), 2, rset.rows) |
|
562 |
rset = self.execute(u'Any N where N has_text "bid�le"') |
|
563 |
self.assertEquals(len(rset.rows), 2, rset.rows) |
|
564 |
biduleeids = [r[0] for r in rset.rows] |
|
565 |
rset = self.execute(u'Any N where NOT N has_text "bid�le"') |
|
566 |
self.failIf([r[0] for r in rset.rows if r[0] in biduleeids]) |
|
567 |
# duh? |
|
568 |
rset = self.execute('Any X WHERE X has_text %(text)s', {'text': u'�a'}) |
|
1787 | 569 |
|
0 | 570 |
def test_select_searchable_text_2(self): |
571 |
rset = self.execute("INSERT Personne X: X nom 'bidule'") |
|
572 |
rset = self.execute("INSERT Personne X: X nom 'chouette'") |
|
573 |
rset = self.execute("INSERT Societe X: X nom 'bidule'") |
|
574 |
self.commit() |
|
575 |
rset = self.execute('Personne N where N has_text "bidule"') |
|
576 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 577 |
|
0 | 578 |
def test_select_searchable_text_3(self): |
579 |
rset = self.execute("INSERT Personne X: X nom 'bidule', X sexe 'M'") |
|
580 |
rset = self.execute("INSERT Personne X: X nom 'bidule', X sexe 'F'") |
|
581 |
rset = self.execute("INSERT Societe X: X nom 'bidule'") |
|
582 |
self.commit() |
|
583 |
rset = self.execute('Any X where X has_text "bidule" and X sexe "M"') |
|
584 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 585 |
|
0 | 586 |
def test_select_multiple_searchable_text(self): |
587 |
self.execute(u"INSERT Personne X: X nom 'bid�le'") |
|
588 |
self.execute("INSERT Societe X: X nom 'chouette', S travaille X") |
|
589 |
self.execute(u"INSERT Personne X: X nom 'bid�le'") |
|
590 |
self.commit() |
|
591 |
rset = self.execute('Personne X WHERE X has_text %(text)s, X travaille S, S has_text %(text2)s', |
|
592 |
{'text': u'bid�le', |
|
593 |
'text2': u'chouette',} |
|
594 |
) |
|
595 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 596 |
|
0 | 597 |
def test_select_no_descr(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
598 |
rset = self.execute('Any X WHERE X is CWGroup', build_descr=0) |
0 | 599 |
rset.rows.sort() |
600 |
self.assertEquals(tuplify(rset.rows), [(1,), (2,), (3,), (4,)]) |
|
601 |
self.assertEquals(rset.description, ()) |
|
602 |
||
603 |
def test_select_limit_offset(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
604 |
rset = self.execute('CWGroup X ORDERBY N LIMIT 2 WHERE X name N') |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
605 |
self.assertEquals(tuplify(rset.rows), [(1,), (2,)]) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
606 |
self.assertEquals(rset.description, [('CWGroup',), ('CWGroup',)]) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
607 |
rset = self.execute('CWGroup X ORDERBY N LIMIT 2 OFFSET 2 WHERE X name N') |
2608
21856eda34f6
[F repo tests] tests have to be updated:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
608 |
self.assertEquals(tuplify(rset.rows), [(3,), (4,)]) |
1787 | 609 |
|
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4204
diff
changeset
|
610 |
def test_select_symmetric(self): |
0 | 611 |
self.execute("INSERT Personne X: X nom 'machin'") |
612 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
613 |
self.execute("INSERT Personne X: X nom 'chouette'") |
|
614 |
self.execute("INSERT Personne X: X nom 'trucmuche'") |
|
615 |
self.execute("SET X connait Y WHERE X nom 'chouette', Y nom 'bidule'") |
|
616 |
self.execute("SET X connait Y WHERE X nom 'machin', Y nom 'chouette'") |
|
617 |
rset = self.execute('Any P where P connait P2') |
|
618 |
self.assertEquals(len(rset.rows), 3, rset.rows) |
|
619 |
rset = self.execute('Any P where NOT P connait P2') |
|
620 |
self.assertEquals(len(rset.rows), 1, rset.rows) # trucmuche |
|
621 |
rset = self.execute('Any P where P connait P2, P2 nom "bidule"') |
|
622 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
623 |
rset = self.execute('Any P where P2 connait P, P2 nom "bidule"') |
|
624 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
625 |
rset = self.execute('Any P where P connait P2, P2 nom "chouette"') |
|
626 |
self.assertEquals(len(rset.rows), 2, rset.rows) |
|
627 |
rset = self.execute('Any P where P2 connait P, P2 nom "chouette"') |
|
628 |
self.assertEquals(len(rset.rows), 2, rset.rows) |
|
1787 | 629 |
|
0 | 630 |
def test_select_inline(self): |
631 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
632 |
self.execute("INSERT Note X: X type 'a'") |
|
633 |
self.execute("SET X ecrit_par Y WHERE X type 'a', Y nom 'bidule'") |
|
634 |
rset = self.execute('Any N where N ecrit_par X, X nom "bidule"') |
|
635 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1787 | 636 |
|
0 | 637 |
def test_select_creation_date(self): |
638 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
639 |
rset = self.execute('Any D WHERE X nom "bidule", X creation_date D') |
|
640 |
self.assertEqual(len(rset.rows), 1) |
|
641 |
||
642 |
def test_select_or_relation(self): |
|
643 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
644 |
self.execute("INSERT Personne X: X nom 'chouette'") |
|
645 |
self.execute("INSERT Societe X: X nom 'logilab'") |
|
646 |
self.execute("INSERT Societe X: X nom 'caesium'") |
|
647 |
self.execute("SET P travaille S WHERE P nom 'bidule', S nom 'logilab'") |
|
648 |
rset = self.execute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
|
649 |
self.assertEqual(len(rset.rows), 1) |
|
650 |
self.execute("SET P travaille S WHERE P nom 'chouette', S nom 'caesium'") |
|
651 |
rset = self.execute('DISTINCT Any P WHERE P travaille S1 OR P travaille S2, S1 nom "logilab", S2 nom "caesium"') |
|
652 |
self.assertEqual(len(rset.rows), 2) |
|
1787 | 653 |
|
0 | 654 |
def test_select_or_sym_relation(self): |
655 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
656 |
self.execute("INSERT Personne X: X nom 'chouette'") |
|
657 |
self.execute("INSERT Personne X: X nom 'truc'") |
|
658 |
self.execute("SET P connait S WHERE P nom 'bidule', S nom 'chouette'") |
|
659 |
rset = self.execute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
|
660 |
self.assertEqual(len(rset.rows), 1, rset.rows) |
|
661 |
rset = self.execute('DISTINCT Any P WHERE P connait S or S connait P, S nom "chouette"') |
|
662 |
self.assertEqual(len(rset.rows), 1, rset.rows) |
|
663 |
self.execute("SET P connait S WHERE P nom 'chouette', S nom 'truc'") |
|
664 |
rset = self.execute('DISTINCT Any P WHERE S connait P, S nom "chouette"') |
|
665 |
self.assertEqual(len(rset.rows), 2, rset.rows) |
|
666 |
rset = self.execute('DISTINCT Any P WHERE P connait S OR S connait P, S nom "chouette"') |
|
667 |
self.assertEqual(len(rset.rows), 2, rset.rows) |
|
1787 | 668 |
|
0 | 669 |
def test_select_follow_relation(self): |
670 |
self.execute("INSERT Affaire X: X sujet 'cool'") |
|
671 |
self.execute("INSERT Societe X: X nom 'chouette'") |
|
672 |
self.execute("SET A concerne S WHERE A is Affaire, S is Societe") |
|
673 |
self.execute("INSERT Note X: X para 'truc'") |
|
674 |
self.execute("SET S evaluee N WHERE S is Societe, N is Note") |
|
675 |
self.execute("INSERT Societe X: X nom 'bidule'") |
|
676 |
self.execute("INSERT Note X: X para 'troc'") |
|
677 |
self.execute("SET S evaluee N WHERE S nom 'bidule', N para 'troc'") |
|
678 |
rset = self.execute('DISTINCT Any A,N WHERE A concerne S, S evaluee N') |
|
679 |
self.assertEqual(len(rset.rows), 1, rset.rows) |
|
680 |
||
681 |
def test_select_ordered_distinct_1(self): |
|
682 |
self.execute("INSERT Affaire X: X sujet 'cool', X ref '1'") |
|
683 |
self.execute("INSERT Affaire X: X sujet 'cool', X ref '2'") |
|
684 |
rset = self.execute('DISTINCT Any S ORDERBY R WHERE A is Affaire, A sujet S, A ref R') |
|
685 |
self.assertEqual(rset.rows, [['cool']]) |
|
686 |
||
687 |
def test_select_ordered_distinct_2(self): |
|
688 |
self.execute("INSERT Affaire X: X sujet 'minor'") |
|
689 |
self.execute("INSERT Affaire X: X sujet 'important'") |
|
690 |
self.execute("INSERT Affaire X: X sujet 'normal'") |
|
691 |
self.execute("INSERT Affaire X: X sujet 'zou'") |
|
692 |
self.execute("INSERT Affaire X: X sujet 'abcd'") |
|
693 |
rset = self.execute('DISTINCT Any S ORDERBY S WHERE A is Affaire, A sujet S') |
|
694 |
self.assertEqual(rset.rows, [['abcd'], ['important'], ['minor'], ['normal'], ['zou']]) |
|
1787 | 695 |
|
0 | 696 |
def test_select_ordered_distinct_3(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
697 |
rset = self.execute('DISTINCT Any N ORDERBY GROUP_SORT_VALUE(N) WHERE X is CWGroup, X name N') |
0 | 698 |
self.assertEqual(rset.rows, [['owners'], ['guests'], ['users'], ['managers']]) |
699 |
||
700 |
def test_select_or_value(self): |
|
701 |
rset = self.execute('Any U WHERE U in_group G, G name "owners" OR G name "users"') |
|
702 |
self.assertEqual(len(rset.rows), 0) |
|
703 |
rset = self.execute('Any U WHERE U in_group G, G name "guests" OR G name "managers"') |
|
704 |
self.assertEqual(len(rset.rows), 2) |
|
705 |
||
706 |
def test_select_explicit_eid(self): |
|
707 |
rset = self.execute('Any X,E WHERE X owned_by U, X eid E, U eid %(u)s', {'u': self.session.user.eid}) |
|
708 |
self.failUnless(rset) |
|
709 |
self.assertEquals(rset.description[0][1], 'Int') |
|
1787 | 710 |
|
0 | 711 |
# def test_select_rewritten_optional(self): |
712 |
# eid = self.execute("INSERT Affaire X: X sujet 'cool'")[0][0] |
|
713 |
# rset = self.execute('Any X WHERE X eid %(x)s, EXISTS(X owned_by U) OR EXISTS(X concerne S?, S owned_by U)', |
|
714 |
# {'x': eid}, 'x') |
|
715 |
# self.assertEquals(rset.rows, [[eid]]) |
|
1787 | 716 |
|
0 | 717 |
def test_today_bug(self): |
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
718 |
self.execute("INSERT Tag X: X name 'bidule', X creation_date NOW") |
0 | 719 |
self.execute("INSERT Tag Y: Y name 'toto'") |
720 |
rset = self.execute("Any D WHERE X name in ('bidule', 'toto') , X creation_date D") |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
721 |
self.assert_(isinstance(rset.rows[0][0], datetime), rset.rows) |
0 | 722 |
rset = self.execute('Tag X WHERE X creation_date TODAY') |
723 |
self.assertEqual(len(rset.rows), 2) |
|
724 |
rset = self.execute('Any MAX(D) WHERE X is Tag, X creation_date D') |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
725 |
self.failUnless(isinstance(rset[0][0], datetime), type(rset[0][0])) |
0 | 726 |
|
727 |
def test_today(self): |
|
728 |
self.execute("INSERT Tag X: X name 'bidule', X creation_date TODAY") |
|
729 |
self.execute("INSERT Tag Y: Y name 'toto'") |
|
730 |
rset = self.execute('Tag X WHERE X creation_date TODAY') |
|
731 |
self.assertEqual(len(rset.rows), 2) |
|
732 |
||
733 |
def test_select_boolean(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
734 |
rset = self.execute('Any N WHERE X is CWEType, X name N, X final %(val)s', |
0 | 735 |
{'val': True}) |
736 |
self.assertEquals(sorted(r[0] for r in rset.rows), ['Boolean', 'Bytes', |
|
737 |
'Date', 'Datetime', |
|
738 |
'Decimal', 'Float', |
|
739 |
'Int', 'Interval', |
|
740 |
'Password', 'String', |
|
741 |
'Time']) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
742 |
rset = self.execute('Any N WHERE X is CWEType, X name N, X final TRUE') |
0 | 743 |
self.assertEquals(sorted(r[0] for r in rset.rows), ['Boolean', 'Bytes', |
744 |
'Date', 'Datetime', |
|
745 |
'Decimal', 'Float', |
|
746 |
'Int', 'Interval', |
|
747 |
'Password', 'String', |
|
748 |
'Time']) |
|
1787 | 749 |
|
0 | 750 |
def test_select_constant(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
751 |
rset = self.execute('Any X, "toto" ORDERBY X WHERE X is CWGroup') |
0 | 752 |
self.assertEquals(rset.rows, |
753 |
map(list, zip((1,2,3,4), ('toto','toto','toto','toto',)))) |
|
754 |
self.assertIsInstance(rset[0][1], unicode) |
|
755 |
self.assertEquals(rset.description, |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
756 |
zip(('CWGroup', 'CWGroup', 'CWGroup', 'CWGroup'), |
0 | 757 |
('String', 'String', 'String', 'String',))) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
758 |
rset = self.execute('Any X, %(value)s ORDERBY X WHERE X is CWGroup', {'value': 'toto'}) |
0 | 759 |
self.assertEquals(rset.rows, |
760 |
map(list, zip((1,2,3,4), ('toto','toto','toto','toto',)))) |
|
761 |
self.assertIsInstance(rset[0][1], unicode) |
|
762 |
self.assertEquals(rset.description, |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
763 |
zip(('CWGroup', 'CWGroup', 'CWGroup', 'CWGroup'), |
0 | 764 |
('String', 'String', 'String', 'String',))) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
765 |
rset = self.execute('Any X,GN WHERE X is CWUser, G is CWGroup, X login "syt", X in_group G, G name GN') |
0 | 766 |
|
767 |
def test_select_union(self): |
|
768 |
rset = self.execute('Any X,N ORDERBY N WITH X,N BEING ' |
|
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
769 |
'((Any X,N WHERE X name N, X transition_of WF, WF workflow_of E, E name %(name)s)' |
0 | 770 |
' UNION ' |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
771 |
'(Any X,N WHERE X name N, X state_of WF, WF workflow_of E, E name %(name)s))', |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
772 |
{'name': 'CWUser'}) |
0 | 773 |
self.assertEquals([x[1] for x in rset.rows], |
774 |
['activate', 'activated', 'deactivate', 'deactivated']) |
|
775 |
self.assertEquals(rset.description, |
|
776 |
[('Transition', 'String'), ('State', 'String'), |
|
777 |
('Transition', 'String'), ('State', 'String')]) |
|
1787 | 778 |
|
0 | 779 |
def test_select_union_aggregat(self): |
780 |
# meaningless, the goal in to have group by done on different attribute |
|
781 |
# for each sub-query |
|
782 |
self.execute('(Any N,COUNT(X) GROUPBY N WHERE X name N, X is State)' |
|
783 |
' UNION ' |
|
784 |
'(Any N,COUNT(X) GROUPBY N ORDERBY 2 WHERE X login N)') |
|
1787 | 785 |
|
0 | 786 |
def test_select_union_aggregat_independant_group(self): |
787 |
self.execute('INSERT State X: X name "hop"') |
|
788 |
self.execute('INSERT State X: X name "hop"') |
|
789 |
self.execute('INSERT Transition X: X name "hop"') |
|
790 |
self.execute('INSERT Transition X: X name "hop"') |
|
791 |
rset = self.execute('Any N,NX ORDERBY 2 WITH N,NX BEING ' |
|
792 |
'((Any N,COUNT(X) GROUPBY N WHERE X name N, X is State HAVING COUNT(X)>1)' |
|
793 |
' UNION ' |
|
794 |
'(Any N,COUNT(X) GROUPBY N WHERE X name N, X is Transition HAVING COUNT(X)>1))') |
|
795 |
self.assertEquals(rset.rows, [[u'hop', 2], [u'hop', 2]]) |
|
1787 | 796 |
|
0 | 797 |
def test_select_union_selection_with_diff_variables(self): |
798 |
rset = self.execute('(Any N WHERE X name N, X is State)' |
|
799 |
' UNION ' |
|
800 |
'(Any NN WHERE XX name NN, XX is Transition)') |
|
801 |
self.assertEquals(sorted(r[0] for r in rset.rows), |
|
802 |
['abort', 'activate', 'activated', 'ben non', |
|
803 |
'deactivate', 'deactivated', 'done', 'en cours', |
|
804 |
'end', 'finie', 'markasdone', 'pitetre', 'redoit', |
|
805 |
'start', 'todo']) |
|
1787 | 806 |
|
5701
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
807 |
def test_select_union_description_diff_var(self): |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
808 |
eid1 = self.execute('CWGroup X WHERE X name "managers"')[0][0] |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
809 |
eid2 = self.execute('CWUser X WHERE X login "admin"')[0][0] |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
810 |
rset = self.execute('(Any X WHERE X eid %(x)s)' |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
811 |
' UNION ' |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
812 |
'(Any Y WHERE Y eid %(y)s)', |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
813 |
{'x': eid1, 'y': eid2}) |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
814 |
self.assertEquals(rset.description[:], [('CWGroup',), ('CWUser',)]) |
41119f034735
[querier] fix rset description bug with some union queries
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5657
diff
changeset
|
815 |
|
0 | 816 |
def test_exists(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
817 |
geid = self.execute("INSERT CWGroup X: X name 'lulufanclub'")[0][0] |
0 | 818 |
self.execute("SET U in_group G WHERE G name 'lulufanclub'") |
819 |
peid = self.execute("INSERT Personne X: X prenom 'lulu', X nom 'petit'")[0][0] |
|
820 |
rset = self.execute("Any X WHERE X prenom 'lulu'," |
|
821 |
"EXISTS (U in_group G, G name 'lulufanclub' OR G name 'managers');") |
|
822 |
self.assertEquals(rset.rows, [[peid]]) |
|
823 |
||
824 |
def test_identity(self): |
|
825 |
eid = self.execute('Any X WHERE X identity Y, Y eid 1')[0][0] |
|
826 |
self.assertEquals(eid, 1) |
|
827 |
eid = self.execute('Any X WHERE Y identity X, Y eid 1')[0][0] |
|
828 |
self.assertEquals(eid, 1) |
|
829 |
login = self.execute('Any L WHERE X login "admin", X identity Y, Y login L')[0][0] |
|
830 |
self.assertEquals(login, 'admin') |
|
831 |
||
832 |
def test_select_date_mathexp(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
833 |
rset = self.execute('Any X, TODAY - CD WHERE X is CWUser, X creation_date CD') |
0 | 834 |
self.failUnless(rset) |
835 |
self.failUnlessEqual(rset.description[0][1], 'Interval') |
|
836 |
eid, = self.execute("INSERT Personne X: X nom 'bidule'")[0] |
|
837 |
rset = self.execute('Any X, NOW - CD WHERE X is Personne, X creation_date CD') |
|
838 |
self.failUnlessEqual(rset.description[0][1], 'Interval') |
|
839 |
||
840 |
def test_select_subquery_aggregat(self): |
|
841 |
# percent users by groups |
|
842 |
self.execute('SET X in_group G WHERE G name "users"') |
|
843 |
rset = self.execute('Any GN, COUNT(X)*100/T GROUPBY GN ORDERBY 2,1' |
|
844 |
' WHERE G name GN, X in_group G' |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
845 |
' WITH T BEING (Any COUNT(U) WHERE U is CWUser)') |
0 | 846 |
self.assertEquals(rset.rows, [[u'guests', 50], [u'managers', 50], [u'users', 100]]) |
847 |
self.assertEquals(rset.description, [('String', 'Int'), ('String', 'Int'), ('String', 'Int')]) |
|
848 |
||
849 |
def test_select_subquery_const(self): |
|
850 |
rset = self.execute('Any X WITH X BEING ((Any NULL) UNION (Any "toto"))') |
|
851 |
self.assertEquals(rset.rows, [[None], ['toto']]) |
|
852 |
self.assertEquals(rset.description, [(None,), ('String',)]) |
|
1787 | 853 |
|
0 | 854 |
# insertion queries tests ################################################# |
1787 | 855 |
|
0 | 856 |
def test_insert_is(self): |
857 |
eid, = self.execute("INSERT Personne X: X nom 'bidule'")[0] |
|
858 |
etype, = self.execute("Any TN WHERE X is T, X eid %s, T name TN" % eid)[0] |
|
859 |
self.assertEquals(etype, 'Personne') |
|
860 |
self.execute("INSERT Personne X: X nom 'managers'") |
|
1787 | 861 |
|
0 | 862 |
def test_insert_1(self): |
863 |
rset = self.execute("INSERT Personne X: X nom 'bidule'") |
|
864 |
self.assertEquals(len(rset.rows), 1) |
|
865 |
self.assertEquals(rset.description, [('Personne',)]) |
|
866 |
rset = self.execute('Personne X WHERE X nom "bidule"') |
|
867 |
self.assert_(rset.rows) |
|
868 |
self.assertEquals(rset.description, [('Personne',)]) |
|
869 |
||
870 |
def test_insert_1_multiple(self): |
|
871 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
872 |
self.execute("INSERT Personne X: X nom 'chouette'") |
|
873 |
rset = self.execute("INSERT Societe Y: Y nom N, P travaille Y WHERE P nom N") |
|
874 |
self.assertEquals(len(rset.rows), 2) |
|
875 |
self.assertEquals(rset.description, [('Societe',), ('Societe',)]) |
|
876 |
||
877 |
def test_insert_2(self): |
|
878 |
rset = self.execute("INSERT Personne X, Personne Y: X nom 'bidule', Y nom 'tutu'") |
|
879 |
self.assertEquals(rset.description, [('Personne', 'Personne')]) |
|
880 |
rset = self.execute('Personne X WHERE X nom "bidule" or X nom "tutu"') |
|
881 |
self.assert_(rset.rows) |
|
882 |
self.assertEquals(rset.description, [('Personne',), ('Personne',)]) |
|
883 |
||
884 |
def test_insert_3(self): |
|
885 |
self.execute("INSERT Personne X: X nom Y WHERE U login 'admin', U login Y") |
|
886 |
rset = self.execute('Personne X WHERE X nom "admin"') |
|
887 |
self.assert_(rset.rows) |
|
1787 | 888 |
self.assertEquals(rset.description, [('Personne',)]) |
0 | 889 |
|
890 |
def test_insert_4(self): |
|
891 |
self.execute("INSERT Societe Y: Y nom 'toto'") |
|
892 |
self.execute("INSERT Personne X: X nom 'bidule', X travaille Y WHERE Y nom 'toto'") |
|
893 |
rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
|
894 |
self.assert_(rset.rows) |
|
895 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
1787 | 896 |
|
0 | 897 |
def test_insert_4bis(self): |
898 |
peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
899 |
seid = self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
|
900 |
{'x': str(peid)})[0][0] |
|
901 |
self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 1) |
|
902 |
self.execute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
|
903 |
{'x': str(seid)}) |
|
904 |
self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 2) |
|
1787 | 905 |
|
0 | 906 |
def test_insert_4ter(self): |
907 |
peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
908 |
seid = self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
|
909 |
{'x': unicode(peid)})[0][0] |
|
910 |
self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 1) |
|
911 |
self.execute("INSERT Personne X: X nom 'chouette', X travaille Y WHERE Y eid %(x)s", |
|
912 |
{'x': unicode(seid)}) |
|
913 |
self.assertEqual(len(self.execute('Any X, Y WHERE X travaille Y')), 2) |
|
914 |
||
915 |
def test_insert_5(self): |
|
916 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
917 |
self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X nom 'bidule'") |
|
918 |
rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
|
919 |
self.assert_(rset.rows) |
|
920 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
921 |
||
4765 | 922 |
def test_insert_5bis(self): |
923 |
peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
924 |
self.execute("INSERT Societe Y: Y nom 'toto', X travaille Y WHERE X eid %(x)s", |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
925 |
{'x': peid}) |
4765 | 926 |
rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
927 |
self.assert_(rset.rows) |
|
928 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
929 |
||
0 | 930 |
def test_insert_6(self): |
931 |
self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto', X travaille Y") |
|
932 |
rset = self.execute('Any X, Y WHERE X nom "bidule", Y nom "toto", X travaille Y') |
|
933 |
self.assert_(rset.rows) |
|
934 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
935 |
||
936 |
def test_insert_7(self): |
|
937 |
self.execute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y WHERE U login 'admin', U login N") |
|
938 |
rset = self.execute('Any X, Y WHERE X nom "admin", Y nom "toto", X travaille Y') |
|
939 |
self.assert_(rset.rows) |
|
940 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
941 |
||
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
942 |
def test_insert_7_2(self): |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
943 |
self.execute("INSERT Personne X, Societe Y: X nom N, Y nom 'toto', X travaille Y WHERE U login N") |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
944 |
rset = self.execute('Any X, Y WHERE Y nom "toto", X travaille Y') |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
945 |
self.assertEquals(len(rset), 2) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
946 |
self.assertEquals(rset.description, [('Personne', 'Societe',), |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
947 |
('Personne', 'Societe',)]) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
948 |
|
0 | 949 |
def test_insert_8(self): |
950 |
self.execute("INSERT Societe Y, Personne X: Y nom N, X nom 'toto', X travaille Y WHERE U login 'admin', U login N") |
|
951 |
rset = self.execute('Any X, Y WHERE X nom "toto", Y nom "admin", X travaille Y') |
|
952 |
self.assert_(rset.rows) |
|
953 |
self.assertEquals(rset.description, [('Personne', 'Societe',)]) |
|
954 |
||
5657
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
955 |
def test_insert_9(self): |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
956 |
self.execute("INSERT Societe X: X nom 'Lo'") |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
957 |
self.execute("INSERT Societe X: X nom 'Gi'") |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
958 |
self.execute("INSERT SubDivision X: X nom 'Lab'") |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
959 |
rset = self.execute("INSERT Personne X: X nom N, X travaille Y, X travaille_subdivision Z WHERE Y is Societe, Z is SubDivision, Y nom N") |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
960 |
self.assertEquals(len(rset), 2) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
961 |
self.assertEquals(rset.description, [('Personne',), ('Personne',)]) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
962 |
# self.assertSetEquals(set(x.nom for x in rset.entities()), |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
963 |
# ['Lo', 'Gi']) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
964 |
# self.assertSetEquals(set(y.nom for x in rset.entities() for y in x.travaille), |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
965 |
# ['Lo', 'Gi']) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
966 |
# self.assertEquals([y.nom for x in rset.entities() for y in x.travaille_subdivision], |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
967 |
# ['Lab', 'Lab']) |
8f56691f01de
[querier] test and fix potential bug in insertion query with multiple relations inside, caused by a name conflict. Also fix another bug non reproduced by using a set instead of a list (list may leads to compare entity instances which isn't allowed).
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
968 |
|
0 | 969 |
def test_insert_query_error(self): |
970 |
self.assertRaises(Exception, |
|
971 |
self.execute, |
|
972 |
"INSERT Personne X: X nom 'toto', X is Personne") |
|
973 |
self.assertRaises(Exception, |
|
974 |
self.execute, |
|
975 |
"INSERT Personne X: X nom 'toto', X is_instance_of Personne") |
|
976 |
self.assertRaises(QueryError, |
|
977 |
self.execute, |
|
978 |
"INSERT Personne X: X nom 'toto', X has_text 'tutu'") |
|
979 |
||
980 |
self.assertRaises(QueryError, |
|
981 |
self.execute, |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
982 |
"INSERT CWUser X: X login 'toto', X eid %s" % cnx.user(self.session).eid) |
0 | 983 |
|
984 |
def test_insertion_description_with_where(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
985 |
rset = self.execute('INSERT CWUser E, EmailAddress EM: E login "X", E upassword "X", ' |
0 | 986 |
'E primary_email EM, EM address "X", E in_group G ' |
987 |
'WHERE G name "managers"') |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
988 |
self.assertEquals(list(rset.description[0]), ['CWUser', 'EmailAddress']) |
1787 | 989 |
|
0 | 990 |
# deletion queries tests ################################################## |
991 |
||
992 |
def test_delete_1(self): |
|
993 |
self.execute("INSERT Personne Y: Y nom 'toto'") |
|
994 |
rset = self.execute('Personne X WHERE X nom "toto"') |
|
995 |
self.assertEqual(len(rset.rows), 1) |
|
3648
665c37544060
on entity deletion query, return eids of deleted entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3589
diff
changeset
|
996 |
drset = self.execute("DELETE Personne Y WHERE Y nom 'toto'") |
665c37544060
on entity deletion query, return eids of deleted entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3589
diff
changeset
|
997 |
self.assertEqual(drset.rows, rset.rows) |
0 | 998 |
rset = self.execute('Personne X WHERE X nom "toto"') |
999 |
self.assertEqual(len(rset.rows), 0) |
|
1787 | 1000 |
|
0 | 1001 |
def test_delete_2(self): |
1002 |
rset = self.execute("INSERT Personne X, Personne Y, Societe Z : X nom 'syt', Y nom 'adim', Z nom 'Logilab', X travaille Z, Y travaille Z") |
|
1003 |
self.assertEquals(len(rset), 1) |
|
1004 |
self.assertEquals(len(rset[0]), 3) |
|
1005 |
self.assertEquals(rset.description[0], ('Personne', 'Personne', 'Societe')) |
|
1006 |
self.assertEquals(self.execute('Any N WHERE X nom N, X eid %s'% rset[0][0])[0][0], 'syt') |
|
1007 |
rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
|
1008 |
self.assertEqual(len(rset.rows), 2, rset.rows) |
|
1009 |
self.execute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilabo'") |
|
1010 |
rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
|
1011 |
self.assertEqual(len(rset.rows), 2, rset.rows) |
|
1012 |
self.execute("DELETE X travaille Y WHERE X is Personne, Y nom 'Logilab'") |
|
1013 |
rset = self.execute('Personne X WHERE X travaille Y, Y nom "Logilab"') |
|
1014 |
self.assertEqual(len(rset.rows), 0, rset.rows) |
|
1015 |
||
1016 |
def test_delete_3(self): |
|
4674
3d509dbb473a
[test api] rename _user_session to user_groups_session, fix its arguments and return only the session, not (user, session) to make things clearer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4467
diff
changeset
|
1017 |
s = self.user_groups_session('users') |
0 | 1018 |
peid, = self.o.execute(s, "INSERT Personne P: P nom 'toto'")[0] |
1019 |
seid, = self.o.execute(s, "INSERT Societe S: S nom 'logilab'")[0] |
|
1020 |
self.o.execute(s, "SET P travaille S") |
|
1021 |
rset = self.execute('Personne P WHERE P travaille S') |
|
1022 |
self.assertEqual(len(rset.rows), 1) |
|
1023 |
self.execute("DELETE X travaille Y WHERE X eid %s, Y eid %s" % (peid, seid)) |
|
1024 |
rset = self.execute('Personne P WHERE P travaille S') |
|
1025 |
self.assertEqual(len(rset.rows), 0) |
|
1026 |
||
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4204
diff
changeset
|
1027 |
def test_delete_symmetric(self): |
0 | 1028 |
teid1 = self.execute("INSERT Folder T: T name 'toto'")[0][0] |
1029 |
teid2 = self.execute("INSERT Folder T: T name 'tutu'")[0][0] |
|
1030 |
self.execute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
|
1031 |
rset = self.execute('Any X,Y WHERE X see_also Y') |
|
1032 |
self.assertEquals(len(rset) , 2, rset.rows) |
|
1033 |
self.execute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
|
1034 |
rset = self.execute('Any X,Y WHERE X see_also Y') |
|
1035 |
self.assertEquals(len(rset) , 0) |
|
1036 |
self.execute('SET X see_also Y WHERE X eid %s, Y eid %s' % (teid1, teid2)) |
|
1037 |
rset = self.execute('Any X,Y WHERE X see_also Y') |
|
1038 |
self.assertEquals(len(rset) , 2) |
|
1039 |
self.execute('DELETE X see_also Y WHERE X eid %s, Y eid %s' % (teid2, teid1)) |
|
1040 |
rset = self.execute('Any X,Y WHERE X see_also Y') |
|
1041 |
self.assertEquals(len(rset) , 0) |
|
1042 |
||
1043 |
def test_nonregr_delete_cache(self): |
|
1044 |
"""test that relations are properly cleaned when an entity is deleted |
|
1045 |
(using cachekey on sql generation returned always the same query for an eid, |
|
1046 |
whatever the relation) |
|
1047 |
""" |
|
4674
3d509dbb473a
[test api] rename _user_session to user_groups_session, fix its arguments and return only the session, not (user, session) to make things clearer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4467
diff
changeset
|
1048 |
s = self.user_groups_session('users') |
0 | 1049 |
aeid, = self.o.execute(s, 'INSERT EmailAddress X: X address "toto@logilab.fr", X alias "hop"')[0] |
1050 |
# XXX would be nice if the rql below was enough... |
|
1051 |
#'INSERT Email X: X messageid "<1234>", X subject "test", X sender Y, X recipients Y' |
|
1052 |
eeid, = self.o.execute(s, 'INSERT Email X: X messageid "<1234>", X subject "test", X sender Y, X recipients Y WHERE Y is EmailAddress')[0] |
|
1053 |
self.o.execute(s, "DELETE Email X") |
|
1054 |
sqlc = s.pool['system'] |
|
1055 |
sqlc.execute('SELECT * FROM recipients_relation') |
|
1056 |
self.assertEquals(len(sqlc.fetchall()), 0) |
|
1057 |
sqlc.execute('SELECT * FROM owned_by_relation WHERE eid_from=%s'%eeid) |
|
1058 |
self.assertEquals(len(sqlc.fetchall()), 0) |
|
1787 | 1059 |
|
0 | 1060 |
def test_nonregr_delete_cache2(self): |
1061 |
eid = self.execute("INSERT Folder T: T name 'toto'")[0][0] |
|
1062 |
self.commit() |
|
1063 |
# fill the cache |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1064 |
self.execute("Any X WHERE X eid %(x)s", {'x': eid}) |
0 | 1065 |
self.execute("Any X WHERE X eid %s" %eid) |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1066 |
self.execute("Folder X WHERE X eid %(x)s", {'x': eid}) |
0 | 1067 |
self.execute("Folder X WHERE X eid %s" %eid) |
1068 |
self.execute("DELETE Folder T WHERE T eid %s"%eid) |
|
1069 |
self.commit() |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1070 |
rset = self.execute("Any X WHERE X eid %(x)s", {'x': eid}) |
0 | 1071 |
self.assertEquals(rset.rows, []) |
1072 |
rset = self.execute("Any X WHERE X eid %s" %eid) |
|
1073 |
self.assertEquals(rset.rows, []) |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1074 |
rset = self.execute("Folder X WHERE X eid %(x)s", {'x': eid}) |
0 | 1075 |
self.assertEquals(rset.rows, []) |
1076 |
rset = self.execute("Folder X WHERE X eid %s" %eid) |
|
1077 |
self.assertEquals(rset.rows, []) |
|
1787 | 1078 |
|
0 | 1079 |
# update queries tests #################################################### |
1080 |
||
1081 |
def test_update_1(self): |
|
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
1082 |
peid = self.execute("INSERT Personne Y: Y nom 'toto'")[0][0] |
0 | 1083 |
rset = self.execute('Personne X WHERE X nom "toto"') |
1084 |
self.assertEqual(len(rset.rows), 1) |
|
2921
8e2544e78a5e
test and fix rset returned by SET query
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2920
diff
changeset
|
1085 |
rset = self.execute("SET X nom 'tutu', X prenom 'original' WHERE X is Personne, X nom 'toto'") |
8e2544e78a5e
test and fix rset returned by SET query
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2920
diff
changeset
|
1086 |
self.assertEqual(tuplify(rset.rows), [(peid, 'tutu', 'original')]) |
0 | 1087 |
rset = self.execute('Any Y, Z WHERE X is Personne, X nom Y, X prenom Z') |
1088 |
self.assertEqual(tuplify(rset.rows), [('tutu', 'original')]) |
|
1787 | 1089 |
|
0 | 1090 |
def test_update_2(self): |
2921
8e2544e78a5e
test and fix rset returned by SET query
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2920
diff
changeset
|
1091 |
peid, seid = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'")[0] |
8e2544e78a5e
test and fix rset returned by SET query
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2920
diff
changeset
|
1092 |
rset = self.execute("SET X travaille Y WHERE X nom 'bidule', Y nom 'toto'") |
8e2544e78a5e
test and fix rset returned by SET query
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2920
diff
changeset
|
1093 |
self.assertEquals(tuplify(rset.rows), [(peid, seid)]) |
0 | 1094 |
rset = self.execute('Any X, Y WHERE X travaille Y') |
1095 |
self.assertEqual(len(rset.rows), 1) |
|
1787 | 1096 |
|
0 | 1097 |
def test_update_2bis(self): |
1098 |
rset = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
|
1099 |
eid1, eid2 = rset[0][0], rset[0][1] |
|
1100 |
self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
|
1101 |
{'x': str(eid1), 'y': str(eid2)}) |
|
1102 |
rset = self.execute('Any X, Y WHERE X travaille Y') |
|
1103 |
self.assertEqual(len(rset.rows), 1) |
|
4795
f1c8bc628b45
[repo] fix bug introduced by 4757:ec9c20c6b9f7, testing for select.selection is not enough to avoid the substep query, we should check there is no interesting restriction (test added)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4787
diff
changeset
|
1104 |
# test add of an existant relation but with NOT X rel Y protection |
f1c8bc628b45
[repo] fix bug introduced by 4757:ec9c20c6b9f7, testing for select.selection is not enough to avoid the substep query, we should check there is no interesting restriction (test added)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4787
diff
changeset
|
1105 |
self.failIf(self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s," |
f1c8bc628b45
[repo] fix bug introduced by 4757:ec9c20c6b9f7, testing for select.selection is not enough to avoid the substep query, we should check there is no interesting restriction (test added)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4787
diff
changeset
|
1106 |
"NOT X travaille Y", |
f1c8bc628b45
[repo] fix bug introduced by 4757:ec9c20c6b9f7, testing for select.selection is not enough to avoid the substep query, we should check there is no interesting restriction (test added)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4787
diff
changeset
|
1107 |
{'x': str(eid1), 'y': str(eid2)})) |
1787 | 1108 |
|
0 | 1109 |
def test_update_2ter(self): |
1110 |
rset = self.execute("INSERT Personne X, Societe Y: X nom 'bidule', Y nom 'toto'") |
|
1111 |
eid1, eid2 = rset[0][0], rset[0][1] |
|
1112 |
self.execute("SET X travaille Y WHERE X eid %(x)s, Y eid %(y)s", |
|
1113 |
{'x': unicode(eid1), 'y': unicode(eid2)}) |
|
1114 |
rset = self.execute('Any X, Y WHERE X travaille Y') |
|
1115 |
self.assertEqual(len(rset.rows), 1) |
|
1787 | 1116 |
|
0 | 1117 |
def test_update_multiple1(self): |
1118 |
peid1 = self.execute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
|
1119 |
peid2 = self.execute("INSERT Personne Y: Y nom 'toto'")[0][0] |
|
1120 |
self.execute("SET X nom 'tutu', Y nom 'toto' WHERE X nom 'toto', Y nom 'tutu'") |
|
1121 |
self.assertEquals(self.execute('Any X WHERE X nom "toto"').rows, [[peid1]]) |
|
1122 |
self.assertEquals(self.execute('Any X WHERE X nom "tutu"').rows, [[peid2]]) |
|
1123 |
||
1124 |
def test_update_multiple2(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1125 |
ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
0 | 1126 |
peid1 = self.execute("INSERT Personne Y: Y nom 'turlu'")[0][0] |
1127 |
peid2 = self.execute("INSERT Personne Y: Y nom 'tutu'")[0][0] |
|
1128 |
self.execute('SET P1 owned_by U, P2 owned_by U ' |
|
1129 |
'WHERE P1 eid %s, P2 eid %s, U eid %s' % (peid1, peid2, ueid)) |
|
1130 |
self.failUnless(self.execute('Any X WHERE X eid %s, X owned_by U, U eid %s' |
|
1131 |
% (peid1, ueid))) |
|
1132 |
self.failUnless(self.execute('Any X WHERE X eid %s, X owned_by U, U eid %s' |
|
1133 |
% (peid2, ueid))) |
|
1134 |
||
1135 |
def test_update_math_expr(self): |
|
1136 |
orders = [r[0] for r in self.execute('Any O ORDERBY O WHERE ST name "Personne", X from_entity ST, X ordernum O')] |
|
1137 |
for i,v in enumerate(orders): |
|
1138 |
if v != orders[0]: |
|
1139 |
splitidx = i |
|
1140 |
break |
|
1141 |
self.execute('SET X ordernum Y+1 WHERE X from_entity SE, SE name "Personne", X ordernum Y, X ordernum >= %(order)s', |
|
1142 |
{'order': orders[splitidx]}) |
|
1143 |
orders2 = [r[0] for r in self.execute('Any O ORDERBY O WHERE ST name "Personne", X from_entity ST, X ordernum O')] |
|
1144 |
orders = orders[:splitidx] + [o+1 for o in orders[splitidx:]] |
|
1145 |
self.assertEquals(orders2, orders) |
|
1146 |
||
1147 |
def test_update_string_concat(self): |
|
1148 |
beid = self.execute("INSERT Bookmark Y: Y title 'toto', Y path '/view'")[0][0] |
|
1149 |
self.execute('SET X title XN + %(suffix)s WHERE X is Bookmark, X title XN', {'suffix': u'-moved'}) |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1150 |
newname = self.execute('Any XN WHERE X eid %(x)s, X title XN', {'x': beid})[0][0] |
0 | 1151 |
self.assertEquals(newname, 'toto-moved') |
1787 | 1152 |
|
0 | 1153 |
def test_update_query_error(self): |
1154 |
self.execute("INSERT Personne Y: Y nom 'toto'") |
|
1155 |
self.assertRaises(Exception, self.execute, "SET X nom 'toto', X is Personne") |
|
1156 |
self.assertRaises(QueryError, self.execute, "SET X nom 'toto', X has_text 'tutu' WHERE X is Personne") |
|
1157 |
self.assertRaises(QueryError, self.execute, "SET X login 'tutu', X eid %s" % cnx.user(self.session).eid) |
|
1158 |
||
1787 | 1159 |
|
0 | 1160 |
# upassword encryption tests ################################################# |
1787 | 1161 |
|
0 | 1162 |
def test_insert_upassword(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1163 |
rset = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'") |
0 | 1164 |
self.assertEquals(len(rset.rows), 1) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1165 |
self.assertEquals(rset.description, [('CWUser',)]) |
0 | 1166 |
self.assertRaises(Unauthorized, |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1167 |
self.execute, "Any P WHERE X is CWUser, X login 'bob', X upassword P") |
0 | 1168 |
cursor = self.pool['system'] |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1169 |
cursor.execute("SELECT %supassword from %sCWUser WHERE %slogin='bob'" |
1251
af40e615dc89
introduce a 'cw_' prefix on entity table and column names so we don't conflict with sql or DBMS specific keywords
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
1170 |
% (SQL_PREFIX, SQL_PREFIX, SQL_PREFIX)) |
1951
f28e7f300d3f
getting a StringIO here was due to lgc.db sqlite adapter bug
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1950
diff
changeset
|
1171 |
passwd = str(cursor.fetchone()[0]) |
1787 | 1172 |
self.assertEquals(passwd, crypt_password('toto', passwd[:2])) |
4199
c9526b1ffb1d
must now properly use Binary for password (see 4180:42247d70105b). XXX Though this is somewhat backend related (eg store password using a binary type), this should be either well document or handled properly in the db helper.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3587
diff
changeset
|
1173 |
rset = self.execute("Any X WHERE X is CWUser, X login 'bob', X upassword %(pwd)s", |
c9526b1ffb1d
must now properly use Binary for password (see 4180:42247d70105b). XXX Though this is somewhat backend related (eg store password using a binary type), this should be either well document or handled properly in the db helper.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3587
diff
changeset
|
1174 |
{'pwd': Binary(passwd)}) |
0 | 1175 |
self.assertEquals(len(rset.rows), 1) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1176 |
self.assertEquals(rset.description, [('CWUser',)]) |
1787 | 1177 |
|
0 | 1178 |
def test_update_upassword(self): |
1179 |
cursor = self.pool['system'] |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1180 |
rset = self.execute("INSERT CWUser X: X login 'bob', X upassword %(pwd)s", {'pwd': 'toto'}) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1181 |
self.assertEquals(rset.description[0][0], 'CWUser') |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1182 |
rset = self.execute("SET X upassword %(pwd)s WHERE X is CWUser, X login 'bob'", |
0 | 1183 |
{'pwd': 'tutu'}) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1184 |
cursor.execute("SELECT %supassword from %sCWUser WHERE %slogin='bob'" |
1251
af40e615dc89
introduce a 'cw_' prefix on entity table and column names so we don't conflict with sql or DBMS specific keywords
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
1185 |
% (SQL_PREFIX, SQL_PREFIX, SQL_PREFIX)) |
1951
f28e7f300d3f
getting a StringIO here was due to lgc.db sqlite adapter bug
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1950
diff
changeset
|
1186 |
passwd = str(cursor.fetchone()[0]) |
1787 | 1187 |
self.assertEquals(passwd, crypt_password('tutu', passwd[:2])) |
4199
c9526b1ffb1d
must now properly use Binary for password (see 4180:42247d70105b). XXX Though this is somewhat backend related (eg store password using a binary type), this should be either well document or handled properly in the db helper.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3587
diff
changeset
|
1188 |
rset = self.execute("Any X WHERE X is CWUser, X login 'bob', X upassword %(pwd)s", |
c9526b1ffb1d
must now properly use Binary for password (see 4180:42247d70105b). XXX Though this is somewhat backend related (eg store password using a binary type), this should be either well document or handled properly in the db helper.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3587
diff
changeset
|
1189 |
{'pwd': Binary(passwd)}) |
0 | 1190 |
self.assertEquals(len(rset.rows), 1) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1191 |
self.assertEquals(rset.description, [('CWUser',)]) |
0 | 1192 |
|
1193 |
# non regression tests #################################################### |
|
1787 | 1194 |
|
0 | 1195 |
def test_nonregr_1(self): |
1196 |
teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
|
1197 |
self.execute("SET X tags Y WHERE X name 'tag', Y is State, Y name 'activated'") |
|
1198 |
rset = self.execute('Any X WHERE T tags X') |
|
1199 |
self.assertEquals(len(rset.rows), 1, rset.rows) |
|
1200 |
rset = self.execute('Any T WHERE T tags X, X is State') |
|
1201 |
self.assertEquals(rset.rows, [[teid]]) |
|
1202 |
rset = self.execute('Any T WHERE T tags X') |
|
1203 |
self.assertEquals(rset.rows, [[teid]]) |
|
1204 |
||
1205 |
def test_nonregr_2(self): |
|
1206 |
teid = self.execute("INSERT Tag X: X name 'tag'")[0][0] |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1207 |
geid = self.execute("CWGroup G WHERE G name 'users'")[0][0] |
0 | 1208 |
self.execute("SET X tags Y WHERE X eid %(t)s, Y eid %(g)s", |
1209 |
{'g': geid, 't': teid}) |
|
1210 |
rset = self.execute('Any X WHERE E eid %(x)s, E tags X', |
|
1211 |
{'x': teid}) |
|
1212 |
self.assertEquals(rset.rows, [[geid]]) |
|
1787 | 1213 |
|
0 | 1214 |
def test_nonregr_3(self): |
1215 |
"""bad sql generated on the second query (destination_state is not |
|
1216 |
detected as an inlined relation) |
|
1217 |
""" |
|
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
1218 |
rset = self.execute('Any S,ES,T WHERE S state_of WF, WF workflow_of ET, ET name "CWUser",' |
0 | 1219 |
'ES allowed_transition T, T destination_state S') |
1220 |
self.assertEquals(len(rset.rows), 2) |
|
1221 |
||
1222 |
def test_nonregr_4(self): |
|
1223 |
# fix variables'type, else we get (nb of entity types with a 'name' attribute)**3 |
|
1224 |
# union queries and that make for instance a 266Ko sql query which is refused |
|
1225 |
# by the server (or client lib) |
|
1226 |
rset = self.execute('Any ER,SE,OE WHERE SE name "Comment", ER name "comments", OE name "Comment",' |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1227 |
'ER is CWRType, SE is CWEType, OE is CWEType') |
0 | 1228 |
self.assertEquals(len(rset), 1) |
1229 |
||
1230 |
def test_nonregr_5(self): |
|
1231 |
# jpl #15505: equivalent queries returning different result sets |
|
1232 |
teid1 = self.execute("INSERT Folder X: X name 'hop'")[0][0] |
|
1233 |
teid2 = self.execute("INSERT Folder X: X name 'hip'")[0][0] |
|
1234 |
neid = self.execute("INSERT Note X: X todo_by U, X filed_under T WHERE U login 'admin', T name 'hop'")[0][0] |
|
1235 |
weid = self.execute("INSERT Affaire X: X concerne N, X filed_under T WHERE N is Note, T name 'hip'")[0][0] |
|
1236 |
rset1 = self.execute('Any N,U WHERE N filed_under T, T eid %s,' |
|
1237 |
'N todo_by U, W concerne N,' |
|
1238 |
'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
|
1239 |
rset2 = self.execute('Any N,U WHERE N filed_under T, T eid %s,' |
|
1240 |
'N todo_by U, W concerne N,' |
|
1241 |
'W filed_under A, A eid %s' % (teid1, teid2)) |
|
1242 |
rset3 = self.execute('Any N,U WHERE N todo_by U, T eid %s,' |
|
1243 |
'N filed_under T, W concerne N,' |
|
1244 |
'W is Affaire, W filed_under A, A eid %s' % (teid1, teid2)) |
|
1245 |
rset4 = self.execute('Any N,U WHERE N todo_by U, T eid %s,' |
|
1246 |
'N filed_under T, W concerne N,' |
|
1247 |
'W filed_under A, A eid %s' % (teid1, teid2)) |
|
1248 |
self.assertEquals(rset1.rows, rset2.rows) |
|
1249 |
self.assertEquals(rset1.rows, rset3.rows) |
|
1250 |
self.assertEquals(rset1.rows, rset4.rows) |
|
1787 | 1251 |
|
0 | 1252 |
def test_nonregr_6(self): |
1253 |
self.execute('Any N,COUNT(S) GROUPBY N ORDERBY COUNT(N) WHERE S name N, S is State') |
|
1787 | 1254 |
|
0 | 1255 |
def test_sqlite_encoding(self): |
1256 |
"""XXX this test was trying to show a bug on use of lower which only |
|
1257 |
occurs with non ascii string and misconfigured locale |
|
1258 |
""" |
|
1259 |
self.execute("INSERT Tag X: X name %(name)s," |
|
1260 |
"X modification_date %(modification_date)s," |
|
1261 |
"X creation_date %(creation_date)s", |
|
1262 |
{'name': u'�name0', |
|
1263 |
'modification_date': '2003/03/12 11:00', |
|
1264 |
'creation_date': '2000/07/03 11:00'}) |
|
1265 |
rset = self.execute('Any lower(N) ORDERBY LOWER(N) WHERE X is Tag, X name N,' |
|
1266 |
'X owned_by U, U eid %(x)s', |
|
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1267 |
{'x':self.session.user.eid}) |
0 | 1268 |
self.assertEquals(rset.rows, [[u'\xe9name0']]) |
1269 |
||
1270 |
||
1271 |
def test_nonregr_description(self): |
|
1272 |
"""check that a correct description is built in case where infered |
|
1273 |
solutions may be "fusionned" into one by the querier while all solutions |
|
1274 |
are needed to build the result's description |
|
1275 |
""" |
|
1276 |
self.execute("INSERT Personne X: X nom 'bidule'") |
|
1277 |
self.execute("INSERT Societe Y: Y nom 'toto'") |
|
1278 |
beid = self.execute("INSERT Basket B: B name 'mybasket'")[0][0] |
|
1279 |
self.execute("SET X in_basket B WHERE X is Personne") |
|
1280 |
self.execute("SET X in_basket B WHERE X is Societe") |
|
1281 |
rset = self.execute('Any X WHERE X in_basket B, B eid %s' % beid) |
|
1282 |
self.assertEquals(len(rset), 2) |
|
1283 |
self.assertEquals(rset.description, [('Personne',), ('Societe',)]) |
|
1284 |
||
1285 |
||
1286 |
def test_nonregr_cache_1(self): |
|
1287 |
peid = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
1288 |
beid = self.execute("INSERT Basket X: X name 'tag'")[0][0] |
|
1289 |
self.execute("SET X in_basket Y WHERE X is Personne, Y eid %(y)s", |
|
1290 |
{'y': beid}) |
|
1291 |
rset = self.execute("Any X WHERE X in_basket B, B eid %(x)s", |
|
1292 |
{'x': beid}) |
|
1293 |
self.assertEquals(rset.rows, [[peid]]) |
|
1294 |
rset = self.execute("Any X WHERE X in_basket B, B eid %(x)s", |
|
1295 |
{'x': beid}) |
|
1296 |
self.assertEquals(rset.rows, [[peid]]) |
|
1297 |
||
1298 |
def test_nonregr_has_text_cache(self): |
|
1299 |
eid1 = self.execute("INSERT Personne X: X nom 'bidule'")[0][0] |
|
1300 |
eid2 = self.execute("INSERT Personne X: X nom 'tag'")[0][0] |
|
1301 |
self.commit() |
|
1302 |
rset = self.execute("Any X WHERE X has_text %(text)s", {'text': 'bidule'}) |
|
1303 |
self.assertEquals(rset.rows, [[eid1]]) |
|
1304 |
rset = self.execute("Any X WHERE X has_text %(text)s", {'text': 'tag'}) |
|
1305 |
self.assertEquals(rset.rows, [[eid2]]) |
|
1306 |
||
1307 |
def test_nonregr_sortterm_management(self): |
|
1308 |
"""Error: Variable has no attribute 'sql' in rql2sql.py (visit_variable) |
|
1309 |
||
1310 |
cause: old variable ref inserted into a fresh rqlst copy |
|
1311 |
(in RQLSpliter._complex_select_plan) |
|
1950
ab7a41b2cd26
reactivate skipped tests due to sqlite bug which is now fixed (sqlite 3.6.13)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1949
diff
changeset
|
1312 |
|
ab7a41b2cd26
reactivate skipped tests due to sqlite bug which is now fixed (sqlite 3.6.13)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1949
diff
changeset
|
1313 |
need sqlite including http://www.sqlite.org/cvstrac/tktview?tn=3773 fix |
0 | 1314 |
""" |
1315 |
self.execute('Any X ORDERBY D DESC WHERE X creation_date D') |
|
1787 | 1316 |
|
0 | 1317 |
def test_nonregr_extra_joins(self): |
1318 |
ueid = self.session.user.eid |
|
1319 |
teid1 = self.execute("INSERT Folder X: X name 'folder1'")[0][0] |
|
1320 |
teid2 = self.execute("INSERT Folder X: X name 'folder2'")[0][0] |
|
1321 |
neid1 = self.execute("INSERT Note X: X para 'note1'")[0][0] |
|
1322 |
neid2 = self.execute("INSERT Note X: X para 'note2'")[0][0] |
|
1323 |
self.execute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
|
1324 |
% (neid1, teid1)) |
|
1325 |
self.execute("SET X filed_under Y WHERE X eid %s, Y eid %s" |
|
1326 |
% (neid2, teid2)) |
|
1327 |
self.execute("SET X todo_by Y WHERE X is Note, Y eid %s" % ueid) |
|
1328 |
rset = self.execute('Any N WHERE N todo_by U, N is Note, U eid %s, N filed_under T, T eid %s' |
|
1329 |
% (ueid, teid1)) |
|
1330 |
self.assertEquals(len(rset), 1) |
|
1331 |
||
1332 |
def test_nonregr_XXX(self): |
|
1333 |
teid = self.execute('Transition S WHERE S name "deactivate"')[0][0] |
|
1334 |
rset = self.execute('Any O WHERE O is State, ' |
|
1335 |
'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
|
1336 |
self.assertEquals(len(rset), 2) |
|
1337 |
rset = self.execute('Any O WHERE O is State, NOT S destination_state O, ' |
|
1338 |
'S eid %(x)s, S transition_of ET, O state_of ET', {'x': teid}) |
|
1339 |
self.assertEquals(len(rset), 1) |
|
1340 |
||
1341 |
||
1342 |
def test_nonregr_set_datetime(self): |
|
1343 |
# huum, psycopg specific |
|
1016
26387b836099
use datetime instead of mx.DateTime
sylvain.thenault@logilab.fr
parents:
439
diff
changeset
|
1344 |
self.execute('SET X creation_date %(date)s WHERE X eid 1', {'date': date.today()}) |
0 | 1345 |
|
1346 |
def test_nonregr_set_query(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1347 |
ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto'")[0][0] |
2920
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
1348 |
self.execute("SET E in_group G, E firstname %(firstname)s, E surname %(surname)s " |
64322aa83a1d
start a new workflow engine
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2608
diff
changeset
|
1349 |
"WHERE E eid %(x)s, G name 'users'", |
5174
78438ad513ca
#759035: Automate addition of eid cachekey in RQL analysis
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4848
diff
changeset
|
1350 |
{'x':ueid, 'firstname': u'jean', 'surname': u'paul'}) |
1787 | 1351 |
|
0 | 1352 |
def test_nonregr_u_owned_by_u(self): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1353 |
ueid = self.execute("INSERT CWUser X: X login 'bob', X upassword 'toto', X in_group G " |
0 | 1354 |
"WHERE G name 'users'")[0][0] |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1355 |
rset = self.execute("CWUser U") |
0 | 1356 |
self.assertEquals(len(rset), 3) # bob + admin + anon |
1357 |
rset = self.execute("Any U WHERE NOT U owned_by U") |
|
1358 |
self.assertEquals(len(rset), 0) # even admin created at repo initialization time should belong to itself |
|
1359 |
||
1360 |
def test_nonreg_update_index(self): |
|
1361 |
# this is the kind of queries generated by "cubicweb-ctl db-check -ry" |
|
1362 |
self.execute("SET X description D WHERE X is State, X description D") |
|
1363 |
||
1364 |
def test_nonregr_is(self): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1365 |
uteid = self.execute('Any ET WHERE ET name "CWUser"')[0][0] |
0 | 1366 |
self.execute('Any X, ET WHERE X is ET, ET eid %s' % uteid) |
1367 |
||
1368 |
def test_nonregr_orderby(self): |
|
1369 |
seid = self.execute('Any X WHERE X name "activated"')[0][0] |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1370 |
self.execute('Any X,S, MAX(T) GROUPBY X,S ORDERBY S WHERE X is CWUser, T tags X, S eid IN(%s), X in_state S' % seid) |
0 | 1371 |
|
1372 |
def test_nonregr_solution_cache(self): |
|
1373 |
self.skip('XXX should be fixed or documented') # (doesn't occur if cache key is provided.) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1374 |
rset = self.execute('Any X WHERE X is CWUser, X eid %(x)s', {'x':self.ueid}) |
0 | 1375 |
self.assertEquals(len(rset), 1) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
1263
diff
changeset
|
1376 |
rset = self.execute('Any X WHERE X is CWUser, X eid %(x)s', {'x':12345}) |
0 | 1377 |
self.assertEquals(len(rset), 0) |
1378 |
||
1379 |
def test_nonregr_final_norestr(self): |
|
1380 |
self.assertRaises(BadRQLQuery, self.execute, 'Date X') |
|
1381 |
||
1382 |
||
1383 |
if __name__ == '__main__': |
|
1384 |
unittest_main() |