cubicweb: comparison cubicweb/test/unittest

equal deleted inserted replaced

-:b4dcfd734686
+:70337ad23145
-# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
 """unit tests for module cubicweb.schema"""
-import sys
+from os.path import join, dirname
-from os.path import join, isabs, basename, dirname
 from logilab.common.testlib import TestCase, unittest_main
 from rql import RQLSyntaxError
 from yams import ValidationError, BadSchemaDefinition
-from yams.constraints import SizeConstraint, StaticVocabularyConstraint
 from yams.buildobjs import (RelationDefinition, EntityType, RelationType,
-Int, String, SubjectRelation, ComputedRelation)
+Int, String, ComputedRelation)
 from yams.reader import fill_schema
 from cubicweb.schema import (
-CubicWebSchema, CubicWebEntitySchema, CubicWebSchemaLoader,
+CubicWebSchema, CubicWebSchemaLoader,
 RQLConstraint, RQLUniqueConstraint, RQLVocabularyConstraint,
-RQLExpression, ERQLExpression, RRQLExpression,
+ERQLExpression, RRQLExpression,
 normalize_expression, order_eschemas, guess_rrqlexpr_mainvars,
 build_schema_from_namespace)
 from cubicweb.devtools import TestServerConfiguration as TestConfiguration
 from cubicweb.devtools.testlib import CubicWebTC
 DATADIR = join(dirname(__file__), 'data')
 # build a dummy schema ########################################################
-PERSONNE_PERMISSIONS =  {
+PERSONNE_PERMISSIONS = {
-'read':   ('managers', 'users', 'guests'),
+'read': ('managers', 'users', 'guests'),
 'update': ('managers', 'owners'),
-'add':    ('managers', ERQLExpression('X travaille S, S owned_by U')),
+'add': ('managers', ERQLExpression('X travaille S, S owned_by U')),
 'delete': ('managers', 'owners',),
 }
 CONCERNE_PERMISSIONS = {
-'read':   ('managers', 'users', 'guests'),
+'read': ('managers', 'users', 'guests'),
-'add':    ('managers', RRQLExpression('U has_update_permission S')),
+'add': ('managers', RRQLExpression('U has_update_permission S')),
 'delete': ('managers', RRQLExpression('O owned_by U')),
 }
 schema = CubicWebSchema('Test Schema')
 enote = schema.add_entity_type(EntityType('Note'))
 eaffaire = schema.add_entity_type(EntityType('Affaire'))
 eperson = schema.add_entity_type(EntityType('Personne', __permissions__=PERSONNE_PERMISSIONS))
 ('Personne  evaluee   Note'),
 ('Societe evaluee   Note'),
 ('Personne  concerne  Affaire'),
 ('Personne  concerne  Societe'),
 ('Affaire concerne  Societe'),
 )
 done = {}
 for rel in RELS:
 _from, _type, _to = rel.split()
 if not _type.lower() in done:
 schema.add_relation_type(RelationType(_type))
 schema.add_relation_def(RelationDefinition(_from, _type, _to,
 __permissions__=CONCERNE_PERMISSIONS))
 else:
 schema.add_relation_def(RelationDefinition(_from, _type, _to))
 class CubicWebSchemaTC(TestCase):
 def test_rql_constraints_inheritance(self):
 # isinstance(cstr, RQLVocabularyConstraint)
 # -> expected to return RQLVocabularyConstraint and RQLConstraint
 ['Any S,U WHERE U has_update_permission S, S eid %(s)s, U eid %(u)s'])
 def test_erqlexpression(self):
 self.assertRaises(RQLSyntaxError, ERQLExpression, '1')
 expr = ERQLExpression('X travaille S, S owned_by U')
-self.assertEqual(str(expr), 'Any X WHERE X travaille S, S owned_by U, X eid %(x)s, U eid %(u)s')
+self.assertEqual(
+str(expr),
+'Any X WHERE X travaille S, S owned_by U, X eid %(x)s, U eid %(u)s')
 expr = ERQLExpression('X foo S, S bar U, X baz XE, S quux SE HAVING XE > SE')
-self.assertEqual(str(expr), 'Any X WHERE X foo S, S bar U, X baz XE, S quux SE, X eid %(x)s, U eid %(u)s HAVING XE > SE')
+self.assertEqual(
+str(expr),
+'Any X WHERE X foo S, S bar U, X baz XE, S quux SE, X eid %(x)s, '
+'U eid %(u)s HAVING XE > SE')
 def test_rrqlexpression(self):
 self.assertRaises(Exception, RRQLExpression, '1')
 self.assertRaises(RQLSyntaxError, RRQLExpression, 'O X Y')
 expr = RRQLExpression('U has_update_permission O')
-self.assertEqual(str(expr), 'Any O,U WHERE U has_update_permission O, O eid %(o)s, U eid %(u)s')
+self.assertEqual(
+str(expr),
+'Any O,U WHERE U has_update_permission O, O eid %(o)s, U eid %(u)s')
 loader = CubicWebSchemaLoader()
 config = TestConfiguration('data', __file__)
 config.bootstrap_cubes()
 class SchemaReaderClassTest(TestCase):
 def test_order_eschemas(self):
 schema = loader.load(config)
 self.assertEqual(order_eschemas([schema['Note'], schema['SubNote']]),
 [schema['Note'], schema['SubNote']])
 self.assertEqual(order_eschemas([schema['SubNote'], schema['Note']]),
 [schema['Note'], schema['SubNote']])
 def test_knownValues_load_schema(self):
 schema = loader.load(config)
 self.assertIsInstance(schema, CubicWebSchema)
 self.assertEqual(schema.name, 'data')
 entities = sorted([str(e) for e in schema.entities()])
-expected_entities = ['Ami', 'BaseTransition', 'BigInt', 'Bookmark', 'Boolean', 'Bytes', 'Card',
+expected_entities = [
-'Date', 'Datetime', 'Decimal',
+'Ami', 'BaseTransition', 'BigInt', 'Bookmark', 'Boolean', 'Bytes', 'Card',
-'CWCache', 'CWComputedRType', 'CWConstraint',
+'Date', 'Datetime', 'Decimal',
-'CWConstraintType', 'CWDataImport', 'CWEType',
+'CWCache', 'CWComputedRType', 'CWConstraint',
-'CWAttribute', 'CWGroup', 'EmailAddress',
+'CWConstraintType', 'CWDataImport', 'CWEType',
-'CWRelation', 'CWPermission', 'CWProperty', 'CWRType',
+'CWAttribute', 'CWGroup', 'EmailAddress',
-'CWSource', 'CWSourceHostConfig', 'CWSourceSchemaConfig',
+'CWRelation', 'CWPermission', 'CWProperty', 'CWRType',
-'CWUniqueTogetherConstraint', 'CWUser',
+'CWSource', 'CWSourceHostConfig', 'CWSourceSchemaConfig',
-'ExternalUri', 'FakeFile', 'Float', 'Int', 'Interval', 'Note',
+'CWUniqueTogetherConstraint', 'CWUser',
-'Password', 'Personne', 'Produit',
+'ExternalUri', 'FakeFile', 'Float', 'Int', 'Interval', 'Note',
-'RQLExpression', 'Reference',
+'Password', 'Personne', 'Produit',
-'Service', 'Societe', 'State', 'StateFull', 'String', 'SubNote', 'SubWorkflowExitPoint',
+'RQLExpression', 'Reference',
-'Tag', 'TZDatetime', 'TZTime', 'Time', 'Transition', 'TrInfo',
+'Service', 'Societe', 'State', 'StateFull', 'String', 'SubNote', 'SubWorkflowExitPoint',
-'Usine',
+'Tag', 'TZDatetime', 'TZTime', 'Time', 'Transition', 'TrInfo',
-'Workflow', 'WorkflowTransition']
+'Usine',
+'Workflow', 'WorkflowTransition',
+]
 self.assertListEqual(sorted(expected_entities), entities)
 relations = sorted([str(r) for r in schema.relations()])
-expected_relations = ['actionnaire', 'add_permission', 'address', 'alias', 'allowed_transition', 'associe',
+expected_relations = [
-'bookmarked_by', 'by_transition', 'buddies',
+'actionnaire', 'add_permission', 'address', 'alias', 'allowed_transition', 'associe',
+'bookmarked_by', 'by_transition', 'buddies',
-'cardinality', 'comment', 'comment_format',
-'composite', 'condition', 'config', 'connait',
+'cardinality', 'comment', 'comment_format',
-'constrained_by', 'constraint_of',
+'composite', 'condition', 'config', 'connait',
-'content', 'content_format', 'contrat_exclusif',
+'constrained_by', 'constraint_of',
-'created_by', 'creation_date', 'cstrtype', 'custom_workflow',
+'content', 'content_format', 'contrat_exclusif',
-'cwuri', 'cw_for_source', 'cw_import_of', 'cw_host_config_of', 'cw_schema', 'cw_source',
+'created_by', 'creation_date', 'cstrtype', 'custom_workflow',
+'cwuri', 'cw_for_source', 'cw_import_of', 'cw_host_config_of', 'cw_schema', 'cw_source',
-'data', 'data_encoding', 'data_format', 'data_name', 'default_workflow', 'defaultval', 'delete_permission',
-'description', 'description_format', 'destination_state', 'dirige',
+'data', 'data_encoding', 'data_format', 'data_name', 'default_workflow', 'defaultval',
+'delete_permission', 'description', 'description_format', 'destination_state',
-'ean', 'ecrit_par', 'eid', 'end_timestamp', 'evaluee', 'expression', 'exprtype', 'extra_props',
+'dirige',
-'fabrique_par', 'final', 'firstname', 'for_user', 'formula', 'fournit',
+'ean', 'ecrit_par', 'eid', 'end_timestamp', 'evaluee', 'expression', 'exprtype',
-'from_entity', 'from_state', 'fulltext_container', 'fulltextindexed',
+'extra_props',
-'has_group_permission', 'has_text',
+'fabrique_par', 'final', 'firstname', 'for_user', 'formula', 'fournit',
-'identity', 'in_group', 'in_state', 'in_synchronization', 'indexed',
+'from_entity', 'from_state', 'fulltext_container', 'fulltextindexed',
-'initial_state', 'inlined', 'internationalizable', 'is', 'is_instance_of',
+'has_group_permission', 'has_text',
-'label', 'last_login_time', 'latest_retrieval', 'lieu', 'log', 'login',
+'identity', 'in_group', 'in_state', 'in_synchronization', 'indexed',
+'initial_state', 'inlined', 'internationalizable', 'is', 'is_instance_of',
-'mainvars', 'match_host', 'modification_date',
+'label', 'last_login_time', 'latest_retrieval', 'lieu', 'log', 'login',
-'name', 'nom',
+'mainvars', 'match_host', 'modification_date',
-'options', 'ordernum', 'owned_by',
+'name', 'nom',
-'parser', 'path', 'pkey', 'prefered_form', 'prenom', 'primary_email',
+'options', 'ordernum', 'owned_by',
-'read_permission', 'relation_type', 'relations', 'require_group', 'rule',
+'parser', 'path', 'pkey', 'prefered_form', 'prenom', 'primary_email',
-'specializes', 'start_timestamp', 'state_of', 'status', 'subworkflow', 'subworkflow_exit', 'subworkflow_state', 'surname', 'symmetric', 'synopsis',
+'read_permission', 'relation_type', 'relations', 'require_group', 'rule',
-'tags', 'timestamp', 'title', 'to_entity', 'to_state', 'transition_of', 'travaille', 'type',
+'specializes', 'start_timestamp', 'state_of', 'status', 'subworkflow',
-'upassword', 'update_permission', 'url', 'uri', 'use_email',
+'subworkflow_exit', 'subworkflow_state', 'surname', 'symmetric', 'synopsis',
-'value',
+'tags', 'timestamp', 'title', 'to_entity', 'to_state', 'transition_of', 'travaille',
+'type',
-'wf_info_for', 'wikiid', 'workflow_of', 'tr_count']
+'upassword', 'update_permission', 'url', 'uri', 'use_email',
+'value',
+'wf_info_for', 'wikiid', 'workflow_of', 'tr_count',
+]
 self.assertListEqual(sorted(expected_relations), relations)
 eschema = schema.eschema('CWUser')
 rels = sorted(str(r) for r in eschema.subject_relations())
 'login', 'modification_date', 'owned_by',
 'primary_email', 'surname', 'upassword',
 'use_email'])
 rels = sorted(r.type for r in eschema.object_relations())
 self.assertListEqual(rels, ['bookmarked_by', 'buddies', 'created_by', 'for_user',
 'identity', 'owned_by', 'wf_info_for'])
 rschema = schema.rschema('relation_type')
 properties = rschema.rdef('CWAttribute', 'CWRType')
 self.assertEqual(properties.cardinality, '1*')
 constraints = properties.constraints
 self.assertEqual(len(constraints), 1, constraints)
 def test_permission_settings(self):
 schema = loader.load(config)
 aschema = schema['TrInfo'].rdef('comment')
 self.assertEqual(aschema.get_groups('read'),
 set(('managers', 'users', 'guests')))
 self.assertEqual(aschema.get_rqlexprs('read'),
 ())
 self.assertEqual(aschema.get_groups('update'),
 set(('managers',)))
 self.assertEqual([x.expression for x in aschema.get_rqlexprs('update')],
 ['U has_update_permission X'])
 def test_nonregr_allowed_type_names(self):
 schema = CubicWebSchema('Test Schema')
 schema.add_entity_type(EntityType('NaN'))
 class Person(EntityType):
 salary = Int()
 class works_for(RelationDefinition):
 subject = 'Person'
-object  = 'Company'
+object = 'Company'
 cardinality = '?*'
 class Company(EntityType):
-total_salary = Int(formula='Any SUM(SA) GROUPBY X WHERE '
+total_salary = Int(formula='Any SUM(SA) GROUPBY X WHERE P works_for X, P salary SA')
-'P works_for X, P salary SA')
 good_schema = build_schema_from_namespace(vars().items())
 rdef = good_schema['Company'].rdef('total_salary')
 # ensure 'X is Company' is added to the rqlst to avoid ambiguities, see #4901163
 self.assertEqual(str(rdef.formula_select),
 'Any SUM(SA) GROUPBY X WHERE P works_for X, P salary SA, X is Company')
 # check relation definition permissions
 self.assertEqual(rdef.permissions,
 {'add': (), 'update': (),
 'read': ('managers', 'users', 'guests')})
-class Company(EntityType):
+class Company(EntityType):  # noqa
 total_salary = String(formula='Any SUM(SA) GROUPBY X WHERE '
 'P works_for X, P salary SA')
 with self.assertRaises(BadSchemaDefinition) as exc:
-bad_schema = build_schema_from_namespace(vars().items())
+build_schema_from_namespace(vars().items())
 self.assertEqual(str(exc.exception),
 'computed attribute total_salary on Company: '
 'computed attribute type (Int) mismatch with '
 'specified type (String)')
 def test_infer_computed_relation(self):
 class Person(EntityType):
 name = String()
 class Company(EntityType):
-name  = String()
+name = String()
 class Service(EntityType):
 name = String()
 class works_for(RelationDefinition):
 rule = 'S produce O'
 schema = build_schema_from_namespace(vars().items())
 # check object/subject type
-self.assertEqual([('Person','Service')],
+self.assertEqual([('Person', 'Service')],
 list(schema['produces_and_buys'].rdefs.keys()))
-self.assertEqual([('Person','Service')],
+self.assertEqual([('Person', 'Service')],
 list(schema['produces_and_buys2'].rdefs.keys()))
 self.assertCountEqual([('Company', 'Service'), ('Person', 'Service')],
 list(schema['reproduce'].rdefs.keys()))
 # check relation definitions are marked infered
-rdef = schema['produces_and_buys'].rdefs[('Person','Service')]
+rdef = schema['produces_and_buys'].rdefs[('Person', 'Service')]
 self.assertTrue(rdef.infered)
 # and have no add/delete permissions
 self.assertEqual(rdef.permissions,
 {'add': (),
 'delete': (),
 def test_rrqlexpr_on_attr(self):
 self._test('rrqlexpr_on_attr.py',
 "can't use RRQLExpression on attribute ToTo.attr[String], use an ERQLExpression")
 def test_rqlexpr_on_computedrel(self):
-self._test('rqlexpr_on_computedrel.py',
+self._test(
-"can't use rql expression for read permission of relation Subject computed Object")
+'rqlexpr_on_computedrel.py',
+"can't use rql expression for read permission of relation Subject computed Object")
 class NormalizeExpressionTC(TestCase):
 def test(self):
 self.assertEqual(normalize_expression('X  bla Y,Y blur Z  ,  Z zigoulou   X '),
 'X bla Y, Y blur Z, Z zigoulou X')
 self.assertEqual(normalize_expression('X bla Y, Y name "x,y"'),
 'X bla Y, Y name "x,y"')
 class RQLExpressionTC(TestCase):
 def test_comparison(self):
 self.assertEqual(ERQLExpression('X is CWUser', 'X', 0),
 ERQLExpression('X is CWUser', 'X', 0))
 self.assertNotEqual(ERQLExpression('X is CWUser', 'X', 0),
 ERQLExpression('X is CWGroup', 'X', 0))
 class GuessRrqlExprMainVarsTC(TestCase):
 def test_exists(self):
-mainvars = guess_rrqlexpr_mainvars(normalize_expression('NOT EXISTS(O team_competition C, C level < 3, C concerns S)'))
+mainvars = guess_rrqlexpr_mainvars(normalize_expression(
+'NOT EXISTS(O team_competition C, C level < 3, C concerns S)'))
 self.assertEqual(mainvars, set(['S', 'O']))
 class RQLConstraintTC(CubicWebTC):
 def test_user_constraint(self):
 with self.admin_access.repo_cnx() as cnx:
 anoneid = cnx.execute('Any X WHERE X login "anon"')[0][0]
 self.assertRaises(ValidationError,
 cstr.repo_check, cnx, 1, 'rel', anoneid)
 self.assertEqual(cstr.repo_check(cnx, 1, cnx.user.eid),
-None) # no validation error, constraint checked
+None)  # no validation error, constraint checked
 class WorkflowShemaTC(CubicWebTC):
 def test_trinfo_default_format(self):
 with self.admin_access.web_request() as req:
 'Transition': [('condition', 'Transition', 'RQLExpression', 'subject')],
 'Workflow': [('state_of', 'State', 'Workflow', 'object'),
 ('transition_of', 'BaseTransition', 'Workflow', 'object'),
 ('transition_of', 'Transition', 'Workflow', 'object'),
 ('transition_of', 'WorkflowTransition', 'Workflow', 'object')],
-'WorkflowTransition': [('condition', 'WorkflowTransition', 'RQLExpression', 'subject'),
+'WorkflowTransition': [
-('subworkflow_exit', 'WorkflowTransition', 'SubWorkflowExitPoint', 'subject')]
+('condition', 'WorkflowTransition', 'RQLExpression', 'subject'),
+('subworkflow_exit', 'WorkflowTransition', 'SubWorkflowExitPoint', 'subject')
+]
 }
 def test_composite_entities(self):
 schema = self.vreg.schema
 self.assertEqual(sorted(self.composites),

changeset 11348	70337ad23145
parent 11279	e4f11ef1face
child 11681	b23d58050076