def test_10_edit_group_name_duplicate(self):
# create a group with testgroupvalues
if not model.Group.by_name(self.testgroupvalues['name']):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.Session.commit()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
rev = model.repo.new_revision()
model.repo.commit_and_remove()
assert model.Group.by_name(self.testgroupvalues['name'])
# create a group with name 'dupname'
dupname = u'dupname'
if not model.Group.by_name(dupname):
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = dupname
model.Session.commit()
assert model.Group.by_name(dupname)
# edit first group to have dupname
group_vals = {'name': dupname}
offset = self.group_offset(self.testgroupvalues['name'])
postparams = '%s=1' % self.dumps(group_vals)
res = self.app.post(offset,
params=postparams,
status=[409],
extra_environ=self.extra_environ)
self.assert_json_response(res, 'Group name already exists')
def test_10_edit_group_name_duplicate(self):
# create a group with testgroupvalues
if not model.Group.by_name(self.testgroupvalues["name"]):
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues["name"]
model.Session.commit()
group = model.Group.by_name(self.testgroupvalues["name"])
model.repo.commit_and_remove()
assert model.Group.by_name(self.testgroupvalues["name"])
# create a group with name 'dupname'
dupname = u"dupname"
if not model.Group.by_name(dupname):
group = model.Group()
model.Session.add(group)
group.name = dupname
model.Session.commit()
assert model.Group.by_name(dupname)
# edit first group to have dupname
group_vals = {"name": dupname}
offset = self.group_offset(self.testgroupvalues["name"])
postparams = "%s=1" % self.dumps(group_vals)
res = self.app.post(
offset,
params=postparams,
status=[409],
extra_environ=self.admin_extra_environ,
)
self.assert_json_response(res, "Group name already exists")
res = self.set_env(self.extra_environ)
def setup(self):
model.Session.remove()
CreateTestData.create(auth_profile='publisher')
self.sysadmin_user = model.User.get('testsysadmin')
self.normal_user = model.User.get(
'annafan') # Does not belong to a publisher
self.publisher1_user = model.User.by_name('russianfan')
self.publisher2_user = model.User.by_name('tester')
# Create two Publishers
rev = model.repo.new_revision()
self.publisher1 = model.Group(name=u'test-publisher1',
title=u'Test Publihser 1',
type=u'publisher')
Session.add(self.publisher1)
self.publisher2 = model.Group(name=u'test-publisher2',
title=u'Test Publihser 2',
type=u'publisher')
Session.add(self.publisher2)
member1 = model.Member(table_name='user',
table_id=self.publisher1_user.id,
group=self.publisher1,
capacity='admin')
Session.add(member1)
member2 = model.Member(table_name='user',
table_id=self.publisher2_user.id,
group=self.publisher2,
capacity='admin')
Session.add(member2)
Session.commit()
def test_largest_groups(self):
# Add packages to groups
model.repo.new_revision()
model.Session.add(model.Group(u'tst1'))
model.Session.add(model.Group(u'tst2'))
model.Session.add(model.Group(u'tst3'))
model.repo.commit_and_remove()
model.repo.new_revision()
for group in model.Session.query(model.Group):
group.packages = []
model.Group.by_name(u'tst1').packages = [
model.Package.by_name(u'gils'),
model.Package.by_name(u'us-gov-images'),
model.Package.by_name(u'usa-courts-gov')
]
model.Group.by_name(u'tst2').packages = [
model.Package.by_name(u'us-gov-images'),
model.Package.by_name(u'usa-courts-gov')
]
model.Group.by_name(u'tst3').packages = [
model.Package.by_name(u'usa-courts-gov')
]
model.repo.commit_and_remove()
res = Stats().largest_groups()
assert len(res) > 2, res
assert res[0] == (model.Group.by_name(u'tst1'), 3), res[0]
assert res[1] == (model.Group.by_name(u'tst2'), 2), res[1]
assert res[2] == (model.Group.by_name(u'tst3'), 1), res[2]
def _create_test_data(cls):
CreateTestData.create()
# Remove visitor and logged in roles
roles = []
q = model.Session.query(model.UserObjectRole).\
filter(model.UserObjectRole.user==model.User.by_name(u"visitor"))
roles.extend(q.all())
q = model.Session.query(model.UserObjectRole).\
filter(model.UserObjectRole.user==model.User.by_name(u"logged_in"))
roles.extend(q.all())
for role in roles:
model.Session.delete(role)
rev = model.repo.new_revision()
model.Session.add_all([
model.User(name=u'pkggroupadmin'),
model.User(name=u'site_reader'),
model.User(name=u'outcast'),
model.Package(name=cls.ENTITY_NAME),
model.Package(name=u'deleted'),
model.Group(name=cls.ENTITY_NAME),
model.Group(name=u'deleted'),
model.Tag(name=cls.ENTITY_NAME),
model.RoleAction(role=cls.TRUSTED_ROLE,
context=u'',
action=model.Action.SITE_READ),
model.RoleAction(role=cls.TRUSTED_ROLE,
context=u'',
action=model.Action.READ),
])
model.repo.commit_and_remove()
# testsysadmin is sysadmin
# annafan is package admin for annakarenina
rev = model.repo.new_revision()
site_reader = model.User.by_name(u'site_reader')
pkggroupadmin = model.User.by_name(u'pkggroupadmin')
pkg = model.Package.by_name(cls.ENTITY_NAME)
group = model.Group.by_name(cls.ENTITY_NAME)
tag = model.Tag.by_name(cls.ENTITY_NAME)
pkg.add_tag(tag)
model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, model.System())
model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, pkg)
model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, group)
model.add_user_to_role(pkggroupadmin, model.Role.ADMIN, pkg)
model.add_user_to_role(pkggroupadmin, model.Role.ADMIN, group)
model.Package.by_name(u'deleted').delete()
model.Group.by_name(u'deleted').delete()
model.repo.commit_and_remove()
cls.testsysadmin = model.User.by_name(u'testsysadmin')
cls.pkggroupadmin = model.User.by_name(u'pkggroupadmin')
cls.site_reader = model.User.by_name(u'site_reader')
cls.outcast = model.User.by_name(u'outcast')
def test_search_by_name_or_title_only_returns_active_groups(self):
active_group = model.Group(name=u'active_group')
active_group.state = u'active'
inactive_group = model.Group(name=u'inactive_group')
inactive_group.state = u'inactive'
model.Session.add(active_group)
model.Session.add(inactive_group)
model.repo.commit_and_remove()
assert_equal(self._search_results('active_group'), set(['active_group']))
assert_equal(self._search_results('inactive_group'), set([]))
def test_search_by_name_or_title_only_returns_active_groups(self):
active_group = model.Group(name=u"active_group")
active_group.state = u"active"
inactive_group = model.Group(name=u"inactive_group")
inactive_group.state = u"inactive"
model.Session.add(active_group)
model.Session.add(inactive_group)
model.repo.commit_and_remove()
assert self._search_results("active_group") == set(["active_group"])
assert self._search_results("inactive_group") == set([])
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
model.Session.add(model.Package(name=u'testpkgag'))
model.Session.add(model.Group(name=u'testgroupag'))
model.Session.add(model.User(name=u'ag_member'))
model.Session.add(model.User(name=u'ag_admin'))
model.Session.add(model.User(name=u'ag_notmember'))
model.Session.add(model.AuthorizationGroup(name=u'authz_group'))
model.repo.commit_and_remove()
pkg = model.Package.by_name(u'testpkgag')
grp = model.Group.by_name(u'testgroupag')
authzgrp = model.AuthorizationGroup.by_name(u'authz_group')
member = model.User.by_name(u'ag_member')
admin = model.User.by_name(u'ag_admin')
model.setup_default_user_roles(authzgrp, [admin])
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, pkg)
model.add_authorization_group_to_role(authzgrp, model.Role.ADMIN, grp)
model.add_user_to_authorization_group(member, authzgrp, model.Role.EDITOR)
model.repo.commit_and_remove()
self.authorizer = ckan.authz.Authorizer()
self.pkg = model.Package.by_name(u'testpkgag')
self.grp = model.Group.by_name(u'testgroupag')
self.member = model.User.by_name(u'ag_member')
self.admin = model.User.by_name(u'ag_admin')
self.notmember = model.User.by_name(u'ag_notmember')
self.authzgrp = model.AuthorizationGroup.by_name(u'authz_group')
def create_groups(cls, group_dicts, admin_user_name=None, auth_profile=""):
'''A more featured interface for creating groups.
All group fields can be filled, packages added and they can
have an admin user.'''
import ckan.model as model
rev = model.repo.new_revision()
# same name as user we create below
rev.author = cls.author
if admin_user_name:
admin_users = [model.User.by_name(admin_user_name)]
else:
admin_users = []
assert isinstance(group_dicts, (list, tuple))
group_attributes = set(('name', 'title', 'description', 'parent_id'))
for group_dict in group_dicts:
group = model.Group(name=unicode(group_dict['name']))
group.type = auth_profile or 'group'
for key in group_dict:
if key in group_attributes:
setattr(group, key, group_dict[key])
else:
group.extras[key] = group_dict[key]
pkg_names = group_dict.get('packages', [])
assert isinstance(pkg_names, (list, tuple))
for pkg_name in pkg_names:
pkg = model.Package.by_name(unicode(pkg_name))
assert pkg, pkg_name
member = model.Member(group=group, table_id=pkg.id, table_name='package')
model.Session.add(member)
model.Session.add(group)
model.setup_default_user_roles(group, admin_users)
cls.group_names.add(group_dict['name'])
model.repo.commit_and_remove()
def roles_user_list(context, data_dict):
'''
Returns the roles of the given user
:returns: roles
:rtype: dictionary
'''
if (check_access('roles_user_list', context, data_dict) == True):
user_name = data_dict.get('user_name')
log.info('Looking up roles for user %r ...', user_name)
try:
user = model.User.get(user_name)
roles = {'System': [], 'Group': [], 'Package': []}
for role in [u'admin', u'editor', u'reader']:
if (authz.user_has_role(user, role, model.System())):
roles['System'].append(role)
if (authz.user_has_role(user, role, model.Package())):
roles['Package'].append(role)
if (authz.user_has_role(user, role, model.Group())):
roles['Group'].append(role)
result = roles
return {'success': True, 'result': result}
except:
return {'success': False, 'msg': traceback.print_exc()}
else:
return {'success': False, 'msg': 'authentication failed'}
def test_2_add_packages(self):
self.russian_group = model.Group(
name=u"russian",
title=u"Russian Group",
description=u"This is the russian group",
)
model.Session.add(self.russian_group)
anna = model.Package.by_name(u"annakarenina")
war = model.Package.by_name(u"warandpeace")
model.Session.add(
model.Member(
group=self.russian_group,
table_id=anna.id,
table_name="package",
))
model.Session.add(
model.Member(group=self.russian_group,
table_id=war.id,
table_name="package"))
model.repo.commit_and_remove()
grp = model.Group.by_name(u"russian")
assert grp.title == u"Russian Group"
anna = model.Package.by_name(u"annakarenina")
war = model.Package.by_name(u"warandpeace")
assert set(grp.packages()) == set((anna, war)), grp.packages()
assert grp in anna.get_groups()
def setup_class(self):
try:
search.clear()
setup_test_search_index()
super(OnsLoaderBase, self).setup_class()
# make annafan a sysadmin to allow package creation
rev = model.repo.new_revision()
user = model.User.by_name(u'annafan')
model.add_user_to_role(user, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
publist = [g.name for g in model.Session.query(model.Group).all()]
# create test publishers
rev = model.repo.new_revision()
for name, title in publishers.items():
if not name in publist:
model.Session.add(model.Group(name=unicode(name), title=title, type='publisher'))
model.repo.commit_and_remove()
except Exception, e:
# ensure that mock_drupal is destroyed
print e
MockDrupalCase.teardown_class()
#model.repo.rebuild_db()
raise
def test_2_add_packages(self):
model.repo.new_revision()
self.russian_group = model.Group(
name=u'russian',
title=u'Russian Group',
description=u'This is the russian group')
model.Session.add(self.russian_group)
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
model.Session.add(
model.Member(group=self.russian_group,
table_id=anna.id,
table_name='package'))
model.Session.add(
model.Member(group=self.russian_group,
table_id=war.id,
table_name='package'))
model.repo.commit_and_remove()
grp = model.Group.by_name(u'russian')
assert grp.title == u'Russian Group'
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
assert set(grp.active_packages().all()) == set(
(anna, war)), grp.active_packages().all()
assert grp in anna.get_groups()
def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.name = u'revisiontest'
# create pkg
self.descriptions = [
u'Written by Puccini', u'Written by Rossini',
u'Not written at all', u'Written again', u'Written off'
]
rev = model.repo.new_revision()
self.grp = model.Group(name=self.name)
model.Session.add(self.grp)
self.grp.description = self.descriptions[0]
self.grp.extras['mykey'] = self.descriptions[0]
model.repo.commit_and_remove()
# edit pkg
for i in range(5)[1:]:
rev = model.repo.new_revision()
grp = model.Group.by_name(self.name)
grp.description = self.descriptions[i]
grp.extras['mykey'] = self.descriptions[i]
model.repo.commit_and_remove()
self.grp = model.Group.by_name(self.name)
def test_add_packages(self):
self.russian_group = model.Group(
name=u"russian",
title=u"Russian Group",
description=u"This is the russian group",
)
model.Session.add(self.russian_group)
pkg1 = factories.Dataset()
pkg2 = factories.Dataset()
model.Session.add(
model.Member(
group=self.russian_group,
table_id=pkg1["id"],
table_name="package",
)
)
model.Session.add(
model.Member(
group=self.russian_group,
table_id=pkg2["id"],
table_name="package",
)
)
model.repo.commit_and_remove()
grp = model.Group.by_name(u"russian")
assert grp.title == u"Russian Group"
anna = model.Package.get(pkg1["id"])
war = model.Package.get(pkg2["id"])
assert set(grp.packages()) == set((anna, war)), grp.packages()
assert grp in anna.get_groups()
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
rev = model.repo.new_revision()
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
rev = model.repo.new_revision()
group = model.Group.by_name(self.testgroupvalues['name'])
model.setup_default_user_roles(group, [self.user])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
model.setup_default_user_roles(group, [user])
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset,
status=[200],
extra_environ=self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
res = self.app.get(offset, status=[403])
self.assert_json_response(res, 'Access denied')
res = self.app.get(offset,
status=[200],
extra_environ=self.extra_environ)
def test_11_delete_group(self):
# Test Groups Entity Delete 200.
# create a group with testgroupvalues
group = model.Group.by_name(self.testgroupvalues['name'])
if not group:
group = model.Group()
model.Session.add(group)
group.name = self.testgroupvalues['name']
model.repo.commit_and_remove()
group = model.Group.by_name(self.testgroupvalues['name'])
model.repo.commit_and_remove()
assert group
user = model.User.by_name(self.user_name)
# delete it
offset = self.group_offset(self.testgroupvalues['name'])
res = self.app.delete(offset, status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
group = model.Group.by_name(self.testgroupvalues['name'])
assert group
assert group.state == 'deleted', group.state
# Anyone can see groups especially sysadmins
# maybe we want to do something different with
# deleted groups but that would be a new requirement
#res = self.app.get(offset, status=[403])
#self.assert_json_response(res, 'Access denied')
res = self.app.get(offset, status=[200],
extra_environ=self.admin_extra_environ)
res = self.set_env(self.extra_environ)
def test_1_basic(self):
group1 = model.Group(name=u'group1', title=u'Test Group',
description=u'This is a test group')
model.Session.add(group1)
model.repo.commit_and_remove()
grp = model.Group.by_name(u'group1')
assert grp.title == u'Test Group'
assert grp.description == u'This is a test group'
assert grp.packages() == []
def add_publisher(cls, publisher_nid):
from ckan import model
from ckan.lib.munge import munge_title_to_name
if int(publisher_nid) in ignore_publishers:
global_log.info('Publisher ignored: %s (%s)', publisher_nid,
cls.get_cached_publisher_details(publisher_nid))
return
pub = cls.get_cached_publisher_details(publisher_nid)
title = pub['title'].strip()
slug = munge_title_to_name(title)
g = model.Group.get(slug)
if g:
global_log.info('Publisher already exists in db: %s', slug)
else:
g = model.Group(name=slug)
model.Session.add(g)
g.title=title
g.type='publisher'
g.description=pub['body']
field_pub_web_title = pub['field_pub_web'][0]['title'] if pub['field_pub_web'] else ''
g.extras['contact-name'] = '%s contact' % field_pub_web_title if field_pub_web_title else ''
g.extras['contact-email'] = pub['field_pub_email_display'][0]['email'] if pub['field_pub_email_display'] else ''
g.extras['contact-phone'] = ''
g.extras['foi-name'] = ''
g.extras['foi-email'] = ''
g.extras['foi-web'] = ''
g.extras['foi-phone'] = ''
acronym = pub['field_acronym'][0]['value'] if pub['field_acronym'] else ''
g.extras['abbreviation'] = acronym or ''
g.extras['website-url'] = (pub['field_pub_web'][0]['url'] or '') if pub['field_pub_web'] else ''
g.extras['website-name'] = (pub['field_pub_web'][0]['title'] or '') if pub['field_pub_web'] else ''
model.Session.commit()
title_and_abbreviation = '%s (%s)' % (title, acronym) if acronym else title
global_log.info('Added/edited publisher: %s <%s>', title_and_abbreviation, publisher_nid)
if pub.get('parent_node'):
parent_pub_title = cls.get_cached_publisher_details(pub['parent_node'])['title']
parent = model.Group.get(munge_title_to_name(parent_pub_title))
if not parent:
parent = cls.add_publisher(pub['parent_node'])
if model.Session.query(model.Member).\
filter(model.Member.group==parent).\
filter(model.Member.table_id==g.id).count() == 0:
m = model.Member(group=parent, table_id=g.id, table_name='group')
model.Session.add(m)
global_log.info('%s is parent of %s', parent.name, g.name)
else:
global_log.info('%s is already a parent of %s', parent.name, g.name)
model.Session.commit()
return g
def setup_class(self):
CreateTestData.create()
model.repo.new_revision()
model.Session.add(model.Package(name=u'testpkg'))
model.Session.add(model.Package(name=u'testpkg2'))
model.Session.add(model.Package(name=u'private_pkg'))
model.Session.add(model.User(name=u'testadmin'))
# Cannot setup testsysadmin user as it is alreade done in
# the default test data.
#model.Session.add(model.User(name=u'testsysadmin'))
model.Session.add(model.User(name=u'notadmin'))
model.Session.add(model.Group(name=u'testgroup'))
model.Session.add(model.Group(name=u'testgroup2'))
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Package.by_name(u'testpkg')
pkg2 = model.Package.by_name(u'testpkg2')
private_pkg = model.Package.by_name(u'private_pkg')
pkg.add_relationship(u'depends_on', pkg2)
pkg.add_relationship(u'depends_on', private_pkg)
model.repo.commit_and_remove()
pkg = model.Package.by_name(u'testpkg')
grp = model.Group.by_name(u'testgroup')
admin = model.User.by_name(u'testadmin')
sysadmin = model.User.by_name(u'testsysadmin')
notadmin = model.User.by_name(u'notadmin')
model.add_user_to_role(admin, model.Role.ADMIN, pkg)
model.add_user_to_role(admin, model.Role.ADMIN, grp)
model.add_user_to_role(sysadmin, model.Role.ADMIN, model.System())
model.add_user_to_role(notadmin, model.Role.READER, pkg)
model.add_user_to_role(notadmin, model.Role.READER, pkg2)
model.repo.commit_and_remove()
self.authorizer = ckan.authz.Authorizer()
self.pkg = model.Package.by_name(u'testpkg')
self.pkg2 = model.Package.by_name(u'testpkg2')
self.private_pkg = model.Package.by_name(u'private_pkg')
self.grp = model.Group.by_name(u'testgroup')
self.grp2 = model.Group.by_name(u'testgroup2')
self.admin = model.User.by_name(u'testadmin')
self.sysadmin = model.User.by_name(u'testsysadmin')
self.notadmin = model.User.by_name(u'notadmin')
def test_package_dictization_with_deleted_group(self):
"""
Ensure that the dictization does not return groups that the dataset has
been removed from.
"""
pkg = model.Package(name="testing-deleted-groups")
group_1 = model.Group(name="test-group-1")
group_2 = model.Group(name="test-group-2")
model.Session.add(pkg)
model.Session.add(group_1)
model.Session.add(group_2)
model.Session.flush()
# Add the dataset to group_1, and signal that the dataset used
# to be a member of group_2 by setting its membership state to 'deleted'
membership_1 = model.Member(
table_id=pkg.id,
table_name="package",
group=group_1,
group_id=group_1.id,
state="active",
)
membership_2 = model.Member(
table_id=pkg.id,
table_name="package",
group=group_2,
group_id=group_2.id,
state="deleted",
)
model.Session.add(membership_1)
model.Session.add(membership_2)
model.repo.commit()
# Dictize the dataset
context = {"model": model, "session": model.Session}
result = package_dictize(pkg, context)
self.remove_changable_columns(result)
assert "test-group-2" not in [g["name"] for g in result["groups"]]
assert "test-group-1" in [g["name"] for g in result["groups"]]
def test_21_package_dictization_with_deleted_group(self):
"""
Ensure that the dictization does not return groups that the dataset has
been removed from.
"""
# Create a new dataset and 2 new groups
model.repo.new_revision()
pkg = model.Package(name='testing-deleted-groups')
group_1 = model.Group(name='test-group-1')
group_2 = model.Group(name='test-group-2')
model.Session.add(pkg)
model.Session.add(group_1)
model.Session.add(group_2)
model.Session.flush()
# Add the dataset to group_1, and signal that the dataset used
# to be a member of group_2 by setting its membership state to 'deleted'
membership_1 = model.Member(table_id = pkg.id,
table_name = 'package',
group = group_1,
group_id = group_1.id,
state = 'active')
membership_2 = model.Member(table_id = pkg.id,
table_name = 'package',
group = group_2,
group_id = group_2.id,
state = 'deleted')
model.Session.add(membership_1)
model.Session.add(membership_2)
model.repo.commit()
# Dictize the dataset
context = {"model": model,
"session": model.Session}
result = package_dictize(pkg, context)
self.remove_changable_columns(result)
assert_not_in('test-group-2', [ g['name'] for g in result['groups'] ])
assert_in('test-group-1', [ g['name'] for g in result['groups'] ])
def test_basic(self):
group = model.Group(
name=factories.Group.stub().name,
title=u"Test Group",
description=u"This is a test group",
)
model.Session.add(group)
model.repo.commit_and_remove()
grp = model.Group.by_name(group.name)
assert grp.title == u"Test Group"
assert grp.description == u"This is a test group"
assert grp.packages() == []
def test_basic(self):
group1 = model.Group(
name=u"group1",
title=u"Test Group",
description=u"This is a test group",
)
model.Session.add(group1)
model.repo.commit_and_remove()
grp = model.Group.by_name(u"group1")
assert grp.title == u"Test Group"
assert grp.description == u"This is a test group"
assert grp.packages() == []
def setup_class(self):
CreateTestData.create()
q = model.Session.query(model.UserObjectRole).filter(
sa.or_(model.UserObjectRole.role == Role.EDITOR,
model.UserObjectRole.role == Role.ANON_EDITOR,
model.UserObjectRole.role == Role.READER))
q = q.filter(
model.UserObjectRole.user == model.User.by_name(u"visitor"))
for role in q:
model.Session.delete(role)
model.repo.commit_and_remove()
model.repo.new_revision()
model.Session.add(model.Package(name=u'testpkg'))
model.Session.add(model.Package(name=u'testpkg2'))
model.Session.add(model.User(name=u'testadmin'))
# Cannot setup testsysadmin user as it is alreade done in
# the default test data.
#model.Session.add(model.User(name=u'testsysadmin'))
model.Session.add(model.User(name=u'notadmin'))
model.Session.add(model.Group(name=u'testgroup'))
model.Session.add(model.Group(name=u'testgroup2'))
model.repo.commit_and_remove()
pkg = model.Package.by_name(u'testpkg')
grp = model.Group.by_name(u'testgroup')
admin = model.User.by_name(u'testadmin')
sysadmin = model.User.by_name(u'testsysadmin')
model.add_user_to_role(admin, model.Role.ADMIN, pkg)
model.add_user_to_role(admin, model.Role.ADMIN, grp)
model.add_user_to_role(sysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
self.authorizer = ckan.authz.Authorizer()
self.pkg = model.Package.by_name(u'testpkg')
self.pkg2 = model.Package.by_name(u'testpkg2')
self.grp = model.Group.by_name(u'testgroup')
self.grp2 = model.Group.by_name(u'testgroup2')
self.admin = model.User.by_name(u'testadmin')
self.sysadmin = model.User.by_name(u'testsysadmin')
self.notadmin = model.User.by_name(u'notadmin')
def setup_class(self):
search.clear()
setup_test_search_index()
super(OnsLoaderBase, self).setup_class()
# make annafan a sysadmin to allow package creation
rev = model.repo.new_revision()
user = model.User.by_name(u'annafan')
model.add_user_to_role(user, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
# create test publishers
rev = model.repo.new_revision()
for name, title in publishers.items():
model.Session.add(
model.Group(name=unicode(name), title=title, type='publisher'))
model.repo.commit_and_remove()
def add_publisher(cls, id, name, title, parent_name):
'''Adds a new publisher using the details'''
from ckan import model
from ckan.lib.munge import munge_title_to_name
log = global_log
model.repo.new_revision()
g = model.Group(name=name, title=title)
model.Session.add(g)
g.id = id
g.type = 'publisher'
## g.extras['contact-name'] = '%s contact' % field_pub_web_title if field_pub_web_title else ''
## g.extras['contact-email'] = pub['field_pub_email_display'][0]['email'] if pub['field_pub_email_display'] else ''
## g.extras['contact-phone'] = ''
## g.extras['foi-name'] = ''
## g.extras['foi-email'] = ''
## g.extras['foi-phone'] = ''
## acronym = pub['field_acronym'][0]['value'] if pub['field_acronym'] else ''
## g.extras['abbreviation'] = acronym or ''
## g.extras['website-url'] = (pub['field_pub_web'][0]['url'] or '') if pub['field_pub_web'] else ''
## g.extras['website-name'] = (pub['field_pub_web'][0]['title'] or '') if pub['field_pub_web'] else ''
model.Session.commit()
if parent_name:
parent = model.Group.get(parent_name)
if not parent:
log.error('Could not add parent that does not exist: %s',
parent_name)
else:
if model.Session.query(model.Member).\
filter(model.Member.group==parent).\
filter(model.Member.table_id==g.id).count() == 0:
m = model.Member(group=parent,
table_id=g.id,
table_name='group')
model.Session.add(m)
log.info('%s is parent of %s', parent_name, g.name)
else:
log.info('%s is already a parent of %s', parent_name,
g.name)
model.Session.commit()
return g
def test_2_add_packages(self):
model.repo.new_revision()
self.russian_group = model.Group(
name=u'russian',
title=u'Russian Group',
description=u'This is the russian group')
model.Session.add(self.russian_group)
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
self.russian_group.packages = [anna, war]
model.repo.commit_and_remove()
grp = model.Group.by_name(u'russian')
assert grp.title == u'Russian Group'
anna = model.Package.by_name(u'annakarenina')
war = model.Package.by_name(u'warandpeace')
assert set(grp.packages) == set((anna, war)), grp.packages
assert grp in anna.groups
def setup_class(self):
# for the authorization editing tests we set up test data so:
# three users, sysadmin , administrator, and another
# one authzgroup, one group, one package
# and administrator is admin on all three
# one extra authzgroup, authzgroup2, with no permissions to start with
model.repo.init_db()
model.repo.new_revision()
self.sysadmin = 'sysadmin'
sysadmin_user = model.User(name=unicode(self.sysadmin))
self.admin = 'administrator'
admin_user = model.User(name=unicode(self.admin))
self.another = 'another'
another_user = model.User(name=unicode(self.another))
self.authzgroup = 'authzgroup'
authzgroup = model.AuthorizationGroup(name=unicode(self.authzgroup))
self.group = 'group'
group = model.Group(name=unicode(self.group))
self.authzgroup2 = 'authzgroup2'
authzgroup2 = model.AuthorizationGroup(name=unicode(self.authzgroup2))
for obj in sysadmin_user, admin_user, another_user, authzgroup, group, authzgroup2:
model.Session.add(obj)
model.add_user_to_role(sysadmin_user, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
model.repo.new_revision()
self.pkg = u'dataset'
pkg = model.Package(name=self.pkg)
model.Session.add(pkg)
admin_user = model.User.by_name(unicode(self.admin))
assert admin_user
# setup all three authorization objects to have logged in and visitor as editors, and the admin as admin
model.setup_user_roles(pkg, ['editor'], ['editor'], [admin_user])
model.setup_user_roles(authzgroup, ['editor'], ['editor'],
[admin_user])
model.setup_user_roles(group, ['editor'], ['editor'], [admin_user])
model.repo.commit_and_remove()
def test_3_search(self):
model.Session.add(
model.Group(name=u"test_org",
title=u"Test org",
type=u"organization"))
model.repo.commit_and_remove()
assert self._search_results("random") == set([])
assert self._search_results("david") == set(["david"])
assert self._search_results("roger") == set(["roger"])
assert self._search_results("roger ") == set(["roger"])
assert self._search_results("David") == set(["david"])
assert self._search_results("Dave") == set(["david"])
assert self._search_results("Dave's") == set(["david"])
assert self._search_results("Dave's books") == set(["david"])
assert self._search_results("Books") == set(["david", "roger"])
assert self._search_results("Books", is_org=True) == set([])
assert self._search_results("Test", is_org=True) == set(["test_org"])
