cubicweb: comparison server/test/unittest

equal deleted inserted replaced

-:eccd1885d42e
+:71c143c0ada3
 Repository.get_versions = get_versions
 def teardown_module(*args):
 Repository.get_versions = orig_get_versions
 class MigrationCommandsTC(RepositoryBasedTC):
 copy_schema = True
 def setUp(self):
 if not hasattr(self, '_repo'):
 # first initialization
 repo = self.repo # set by the RepositoryBasedTC metaclass
 # force to read schema from the database
 self.mh = ServerMigrationHelper(self.repo.config, migrschema,
 repo=self.repo, cnx=self.cnx,
 interactive=False)
 assert self.cnx is self.mh._cnx
 assert self.session is self.mh.session, (self.session.id, self.mh.session.id)
 def test_add_attribute_int(self):
 self.failIf('whatever' in self.schema)
 paraordernum = self.mh.rqlexec('Any O WHERE X name "Note", RT name "para", RDEF from_entity X, RDEF relation_type RT, RDEF ordernum O')[0][0]
 self.mh.cmd_add_attribute('Note', 'whatever')
 self.failUnless('whatever' in self.schema)
 # test created column is actually a varchar(64)
 notesql = self.mh.sqlexec("SELECT sql FROM sqlite_master WHERE type='table' and name='%sNote'" % SQL_PREFIX)[0][0]
 fields = dict(x.strip().split()[:2] for x in notesql.split('(', 1)[1].rsplit(')', 1)[0].split(','))
 self.assertEquals(fields['%sshortpara' % SQL_PREFIX], 'varchar(64)')
 self.mh.rollback()
 def test_add_datetime_with_default_value_attribute(self):
 self.failIf('mydate' in self.schema)
 self.mh.cmd_add_attribute('Note', 'mydate')
 self.failUnless('mydate' in self.schema)
 self.assertEquals(self.schema['mydate'].subjects(), ('Note', ))
 d1 = self.mh.rqlexec('Any D WHERE X eid %(x)s, X mydate D', {'x': eid1}, 'x')[0][0]
 d2 = self.mh.rqlexec('Any D WHERE X eid %(x)s, X mydate D', {'x': eid2}, 'x')[0][0]
 self.assertEquals(d1, date.today())
 self.assertEquals(d2, testdate)
 self.mh.rollback()
 def test_rename_attribute(self):
 self.failIf('civility' in self.schema)
 eid1 = self.mh.rqlexec('INSERT Personne X: X nom "lui", X sexe "M"')[0][0]
 eid2 = self.mh.rqlexec('INSERT Personne X: X nom "l\'autre", X sexe NULL')[0][0]
 self.mh.cmd_rename_attribute('Personne', 'sexe', 'civility')
 t1 = self.mh.rqlexec('Any N WHERE T transition_of ET, ET name "%s", T name N' %
 etype)[0][0]
 self.assertEquals(t1, "baz")
 gn = self.mh.rqlexec('Any GN WHERE T require_group G, G name GN, T eid %s' % baz)[0][0]
 self.assertEquals(gn, 'managers')
 def test_add_entity_type(self):
 self.failIf('Folder2' in self.schema)
 self.failIf('filed_under2' in self.schema)
 self.mh.cmd_add_entity_type('Folder2')
 self.failUnless('Folder2' in self.schema)
 'filed_under2', 'has_text', 'identity', 'is', 'is_instance_of',
 'modification_date', 'name', 'owned_by'])
 self.assertEquals([str(rs) for rs in self.schema['Folder2'].object_relations()],
 ['filed_under2', 'identity'])
 self.assertEquals(sorted(str(e) for e in self.schema['filed_under2'].subjects()),
 ['Affaire', 'Card', 'Division', 'Email', 'EmailThread', 'File',
 'Folder2', 'Image', 'Note', 'Personne', 'Societe', 'SubDivision'])
 self.assertEquals(self.schema['filed_under2'].objects(), ('Folder2',))
 eschema = self.schema.eschema('Folder2')
 for cstr in eschema.constraints('name'):
 self.failUnless(hasattr(cstr, 'eid'))
 def test_add_relation_type(self):
 self.mh.cmd_add_entity_type('Folder2', auto=False)
 self.mh.cmd_add_relation_type('filed_under2')
 self.failUnless('filed_under2' in self.schema)
 self.assertEquals(sorted(str(e) for e in self.schema['filed_under2'].subjects()),
 ['Affaire', 'Card', 'Division', 'Email', 'EmailThread', 'File',
 'Folder2', 'Image', 'Note', 'Personne', 'Societe', 'SubDivision'])
 self.assertEquals(self.schema['filed_under2'].objects(), ('Folder2',))
 def test_drop_relation_type(self):
 self.mh.cmd_drop_relation_type('filed_under2')
 self.failIf('filed_under2' in self.schema)
 def test_add_relation_definition(self):
 self.mh.cmd_add_relation_definition('Societe', 'in_state', 'State')
-self.assertEquals(sorted(self.schema['in_state'].subjects()),
+self.assertEquals(sorted(str(x) for x in self.schema['in_state'].subjects()),
-['Affaire', 'Division', 'CWUser', 'Note', 'Societe', 'SubDivision'])
+['Affaire', 'CWUser', 'Division', 'Note', 'Societe', 'SubDivision'])
 self.assertEquals(self.schema['in_state'].objects(), ('State',))
 def test_add_relation_definition_nortype(self):
 self.mh.cmd_add_relation_definition('Personne', 'concerne2', 'Affaire')
 self.assertEquals(self.schema['concerne2'].subjects(),
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].subjects()), ['Affaire', 'Personne'])
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].objects()), ['Affaire', 'Division', 'Note', 'Societe', 'SubDivision'])
 self.mh.cmd_drop_relation_definition('Personne', 'concerne', 'Affaire')
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].subjects()), ['Affaire'])
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].objects()), ['Division', 'Note', 'Societe', 'SubDivision'])
 def test_drop_relation_definition_with_specialization(self):
 self.failUnless('concerne' in self.schema)
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].subjects()), ['Affaire', 'Personne'])
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].objects()), ['Affaire', 'Division', 'Note', 'Societe', 'SubDivision'])
 self.mh.cmd_drop_relation_definition('Affaire', 'concerne', 'Societe')
 self.mh.cmd_drop_relation_definition('None', 'concerne', 'Societe')
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].subjects()), ['Affaire', 'Personne'])
 self.assertEquals(sorted(str(e) for e in self.schema['concerne'].objects()), ['Affaire', 'Note'])
 def test_drop_relation_definition2(self):
 self.failUnless('evaluee' in self.schema)
 self.mh.cmd_drop_relation_definition('Personne', 'evaluee', 'Note')
 self.failUnless('evaluee' in self.schema)
 self.assertEquals(sorted(self.schema['evaluee'].subjects()),
-['Division', 'CWUser', 'Societe', 'SubDivision'])
+['CWUser', 'Division', 'Societe', 'SubDivision'])
 self.assertEquals(sorted(self.schema['evaluee'].objects()),
 ['Note'])
 def test_rename_relation(self):
 self.skip('implement me')
 card = rschema.rproperty('Affaire', 'Societe', 'cardinality')
 self.assertEquals(card, '?*')
 finally:
 self.mh.cmd_change_relation_props('Affaire', 'concerne', 'Societe',
 cardinality='**')
 def test_change_relation_props_final(self):
 rschema = self.schema['adel']
 card = rschema.rproperty('Personne', 'String', 'fulltextindexed')
 self.assertEquals(card, False)
 try:
 #                     'nom', 'prenom', 'civility', 'promo', 'ass', 'adel', 'titre',
 #                     'web', 'tel', 'fax', 'datenaiss', 'test']
 #         self.assertEquals([rs.type for rs in migrschema['Personne'].ordered_relations() if rs.is_final()],
 #                           expected)
 migrschema['Personne'].description = 'blabla bla'
 migrschema['titre'].description = 'usually a title'
 migrschema['titre']._rproperties[('Personne', 'String')]['description'] = 'title for this person'
 #         rinorderbefore = cursor.execute('Any O,N WHERE X is CWAttribute, X relation_type RT, RT name N,'
 #                                         'X from_entity FE, FE name "Personne",'
 #                                         'X ordernum O ORDERBY O')
 #         expected = [u'creation_date', u'modification_date', u'nom', u'prenom',
 #                     u'sexe', u'promo', u'titre', u'adel', u'ass', u'web', u'tel',
 #                     u'fax', u'datenaiss', u'test', u'description']
 #        self.assertListEquals(rinorderbefore, map(list, zip([0, 0]+range(1, len(expected)), expected)))
-self.mh.cmd_synchronize_schema(commit=False)
+self.mh.cmd_sync_schema_props_perms(commit=False)
 self.assertEquals(cursor.execute('Any D WHERE X name "Personne", X description D')[0][0],
 'blabla bla')
 self.assertEquals(cursor.execute('Any D WHERE X name "titre", X description D')[0][0],
 'usually a title')
 self.assertEquals(cursor.execute('Any D WHERE X relation_type RT, RT name "titre",'
 self.assertEquals(eexpr.reverse_delete_permission, [])
 self.assertEquals(eexpr.reverse_update_permission, [])
 # no more rqlexpr to delete and add para attribute
 self.failIf(self._rrqlexpr_rset('add', 'para'))
 self.failIf(self._rrqlexpr_rset('delete', 'para'))
 # new rql expr to add ecrit_par relation
 rexpr = self._rrqlexpr_entity('add', 'ecrit_par')
 self.assertEquals(rexpr.expression,
 'O require_permission P, P name "add_note", '
 'U in_group G, P require_group G')
 self.assertEquals([rt.name for rt in rexpr.reverse_add_permission], ['ecrit_par'])
 #   * 2 new (Note add, ecrit_par add)
 # remaining orphan rql expr which should be deleted at commit (composite relation)
 self.assertEquals(len(cursor.execute('RQLExpression X WHERE NOT ET1 read_permission X, NOT ET2 add_permission X, '
 'NOT ET3 delete_permission X, NOT ET4 update_permission X')), 8+1)
 # finally
 self.assertEquals(len(cursor.execute('RQLExpression X')), nbrqlexpr_start + 1 + 2)
 self.mh.rollback()
 def _erqlexpr_rset(self, action, ertype):
 rql = 'RQLExpression X WHERE ET is CWEType, ET %s_permission X, ET name %%(name)s' % action
 return self.mh.rqlcursor.execute(rql, {'name': ertype})
 return self.mh.rqlcursor.execute(rql, {'name': ertype})
 def _rrqlexpr_entity(self, action, ertype):
 rset = self._rrqlexpr_rset(action, ertype)
 self.assertEquals(len(rset), 1)
 return rset.get_entity(0, 0)
 def test_set_size_constraint(self):
 # existing previous value
 try:
 self.mh.cmd_set_size_constraint('CWEType', 'name', 128)
 finally:
 self.mh.cmd_remove_cube('email')
 # file was there because it's an email dependancy, should have been removed
 cubes.remove('email')
 cubes.remove('file')
 self.assertEquals(set(self.config.cubes()), cubes)
 for ertype in ('Email', 'EmailThread', 'EmailPart', 'File', 'Image',
 'sender', 'in_thread', 'reply_to', 'data_format'):
 self.failIf(ertype in schema, ertype)
 self.assertEquals(sorted(schema['see_also']._rproperties.keys()),
 sorted([('Folder', 'Folder'),
 ('Bookmark', 'Bookmark'),
 finally:
 self.mh.cmd_add_cube('email')
 cubes.add('email')
 cubes.add('file')
 self.assertEquals(set(self.config.cubes()), cubes)
 for ertype in ('Email', 'EmailThread', 'EmailPart', 'File', 'Image',
 'sender', 'in_thread', 'reply_to', 'data_format'):
 self.failUnless(ertype in schema, ertype)
 self.assertEquals(sorted(schema['see_also']._rproperties.keys()),
 sorted([('EmailThread', 'EmailThread'), ('Folder', 'Folder'),
 ('Bookmark', 'Bookmark'),
 # trick: overwrite self.maxeid to avoid deletion of just reintroduced
 #        types (and their associated tables!)
 self.maxeid = self.execute('Any MAX(X)')[0][0]
 # why this commit is necessary is unclear to me (though without it
 # next test may fail complaining of missing tables
 self.commit()
 def test_set_state(self):
 user = self.session.user
-self.set_debug(True)
 self.mh.set_state(user.eid, 'deactivated')
 user.clear_related_cache('in_state', 'subject')
-try:
+self.assertEquals(user.state, 'deactivated')
-self.assertEquals(user.state, 'deactivated')
-finally:
-self.set_debug(False)
 if __name__ == '__main__':
 unittest_main()

branch	tls-sprint
changeset 1787	71c143c0ada3
parent 1398	5fe84a5f7035
child 1977	606923dff11b