def test_that_it_does_not_return_groups(self):
"""
organization_list_for_user() should not return groups that the user is
a member, editor or admin of.
"""
user = factories.User()
context = {'user': user['name']}
group_1 = factories.Group()
group_2 = factories.Group()
group_3 = factories.Group()
helpers.call_action('member_create', id=group_1['id'],
object=user['id'], object_type='user',
capacity='member')
helpers.call_action('member_create', id=group_2['id'],
object=user['id'], object_type='user',
capacity='editor')
helpers.call_action('member_create', id=group_3['id'],
object=user['id'], object_type='user',
capacity='admin')
organizations = helpers.call_action('organization_list_for_user',
context=context)
assert organizations == []
def test_group_list_groups_returned(self):
parent_group = factories.Group(tags=[{'name': 'river'}])
child_group = factories.Group(groups=[{
'name': parent_group['name']
}],
tags=[{
'name': 'river'
}])
group_list = helpers.call_action('group_list',
all_fields=True,
include_groups=True)
child_group_returned = group_list[0]
if group_list[0]['name'] == child_group['name']:
child_group_returned, parent_group_returned = group_list
else:
child_group_returned, parent_group_returned = group_list[::-1]
expected_parent_group = dict(parent_group.items()[:])
for field in ('users', 'tags', 'extras'):
del expected_parent_group[field]
expected_parent_group['capacity'] = u'public'
expected_parent_group['packages'] = 0
expected_parent_group['package_count'] = 0
eq(child_group_returned['groups'], [expected_parent_group])
def test_group_list(self):
group1 = factories.Group()
group2 = factories.Group()
group_list = helpers.call_action('group_list')
assert (sorted(group_list) ==
sorted([g['name'] for g in [group1, group2]]))
def test_group_list_in_presence_of_custom_group_types(self):
'''Getting the group_list shouldn't return custom group types.'''
group1 = factories.Group()
group2 = factories.Group()
factories.Group(type='custom')
group_list = helpers.call_action('group_list')
assert (sorted(group_list) ==
sorted([g['name'] for g in [group1, group2]]))
def test_group_list_dictize_sorted(self):
factories.Group(name='aa')
factories.Group(name='bb')
group_list = [model.Group.get(u'bb'), model.Group.get(u'aa')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list, context)
# list is resorted by name
assert_equal(group_dicts[0]['name'], 'aa')
assert_equal(group_dicts[1]['name'], 'bb')
def test_group_list_sort_by_package_count(self):
factories.Group(name='aa')
factories.Group(name='bb')
factories.Dataset(groups=[{'name': 'aa'}, {'name': 'bb'}])
factories.Dataset(groups=[{'name': 'bb'}])
group_list = helpers.call_action('group_list', sort='package_count')
# default is descending order
eq(group_list, ['bb', 'aa'])
def test_group_dictize_group_with_parent_group(self):
factories.Group(name='parent')
factories.Group(name='child', groups=[{'name': 'parent'}])
group_obj = model.Group.get('child')
context = {'model': model, 'session': model.Session}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(len(group['groups']), 1)
assert_equal(group['groups'][0]['name'], 'parent')
assert_equal(group['groups'][0]['packages'], 0) # deprecated
assert_equal(group['groups'][0]['package_count'], 0)
def test_group_list_dictize_including_groups(self):
factories.Group(name='parent')
factories.Group(name='child', groups=[{'name': 'parent'}])
group_list = [model.Group.get(u'parent'), model.Group.get(u'child')]
context = {'model': model, 'session': model.Session}
child_dict, parent_dict = model_dictize.group_list_dictize(
group_list, context, include_groups=True)
assert_equal(parent_dict['name'], 'parent')
assert_equal(child_dict['name'], 'child')
assert_equal(parent_dict['groups'], [])
assert_equal(child_dict['groups'][0]['name'], 'parent')
def test_organization_list_in_presence_of_custom_group_types(self):
'''
Getting the organization_list only returns organization group
types.
'''
org1 = factories.Organization()
org2 = factories.Organization()
factories.Group(type="custom")
factories.Group(type="custom")
org_list = helpers.call_action('organization_list')
assert (sorted(org_list) == sorted([g['name'] for g in [org1, org2]]))
def test_group_list_in_presence_of_organizations(self):
'''
Getting the group_list should only return groups of type 'group' (not
organizations).
'''
group1 = factories.Group()
group2 = factories.Group()
factories.Organization()
factories.Organization()
group_list = helpers.call_action('group_list')
assert (sorted(group_list) ==
sorted([g['name'] for g in [group1, group2]]))
def test_group_list_return_custom_group(self):
'''
Getting the group_list with a type defined should only return
groups of that type.
'''
group1 = factories.Group(type='custom')
group2 = factories.Group(type='custom')
factories.Group()
factories.Group()
group_list = helpers.call_action('group_list', type='custom')
assert (sorted(group_list) ==
sorted([g['name'] for g in [group1, group2]]))
def test_atom_feed_page_zero_gives_error(self):
group = factories.Group()
offset = url_for(controller='feed', action='group',
id=group['name']) + '?page=0'
app = self._get_test_app()
res = app.get(offset, status=400)
assert '"page" parameter must be a positive integer' in res, res
def test_group_show_no_packages_returned(self):
user_name = helpers.call_action('get_site_user')['name']
group = factories.Group()
datasets = [
{
'name': 'dataset_1',
'groups': [{
'name': group['name']
}]
},
{
'name': 'dataset_2',
'groups': [{
'name': group['name']
}]
},
]
for dataset in datasets:
helpers.call_action('package_create',
context={'user': user_name},
**dataset)
group_dict = helpers.call_action('group_show',
id=group['id'],
include_datasets=False)
assert not 'packages' in group_dict
assert group_dict['package_count'] == 2
def test_organization_show_error_for_group(self):
group = factories.Group()
nose.tools.assert_raises(
logic.NotFound,
helpers.call_action, 'organization_show', id=group['id'])
def test_group_show_packages_returned(self):
user_name = helpers.call_action('get_site_user')['name']
group = factories.Group(user=factories.User())
datasets = [
{
'name': 'dataset_1',
'groups': [{
'name': group['name']
}]
},
{
'name': 'dataset_2',
'groups': [{
'name': group['name']
}]
},
]
for dataset in datasets:
helpers.call_action('package_create',
context={'user': user_name},
**dataset)
group_dict = helpers.call_action('group_show', id=group['id'])
assert len(group_dict['packages']) == 2
assert group_dict['package_count'] == 2
def test_group_show_does_not_show_private_datasets(self):
'''group_show() should never show private datasets.
If a dataset is a private member of an organization and also happens to
be a member of a group, group_show() should not return the dataset as
part of the group dict, even if the user calling group_show() is a
member or admin of the group or the organization or is a sysadmin.
'''
org_member = factories.User()
org = factories.Organization(user=org_member)
private_dataset = factories.Dataset(user=org_member,
owner_org=org['name'],
private=True)
group = factories.Group()
# Add the private dataset to the group.
helpers.call_action('member_create',
id=group['id'],
object=private_dataset['id'],
object_type='package',
capacity='public')
# Create a member user and an admin user of the group.
group_member = factories.User()
helpers.call_action('member_create',
id=group['id'],
object=group_member['id'],
object_type='user',
capacity='member')
group_admin = factories.User()
helpers.call_action('member_create',
id=group['id'],
object=group_admin['id'],
object_type='user',
capacity='admin')
# Create a user who isn't a member of any group or organization.
non_member = factories.User()
sysadmin = factories.Sysadmin()
# None of the users should see the dataset when they call group_show().
for user in (org_member, group_member, group_admin, non_member,
sysadmin, None):
if user is None:
context = None # No user logged-in.
else:
context = {'user': user['name']}
group = helpers.call_action('group_show',
id=group['id'],
context=context)
assert private_dataset['id'] not in [
dataset['id'] for dataset in group['packages']
], ("group_show() should never show private datasets")
def test_group_dictize_group_with_extra(self):
factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
group_obj = model.Session.query(model.Group).filter_by().first()
context = {'model': model, 'session': model.Session}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(group['extras'][0]['key'], 'k1')
def test_group_list_dictize_sort_by_package_count(self):
factories.Group(name='aa')
factories.Group(name='bb')
factories.Dataset(groups=[{'name': 'aa'}, {'name': 'bb'}])
factories.Dataset(groups=[{'name': 'bb'}])
group_list = [model.Group.get(u'bb'), model.Group.get(u'aa')]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list,
context,
sort_key=lambda x: x['package_count'],
with_package_counts=True)
# list is resorted by package counts
assert_equal(group_dicts[0]['name'], 'aa')
assert_equal(group_dicts[1]['name'], 'bb')
def _get_group_edit_page(app, group_type, group_name=None):
user = factories.User()
if group_name is None:
group = factories.Group(user=user, type=group_type)
group_name = group['name']
env = {'REMOTE_USER': user['name'].encode('ascii')}
url = url_for('%s_edit' % group_type, id=group_name)
response = app.get(url=url, extra_environ=env)
return env, response, group_name
def test_group_list_extras_returned(self):
group = factories.Group(extras=[{'key': 'key1', 'value': 'val1'}])
group_list = helpers.call_action('group_list', all_fields=True,
include_extras=True)
eq(group_list[0]['extras'], group['extras'])
eq(group_list[0]['extras'][0]['key'], 'key1')
def test_showing_group_in_showing_list_for_user_excludes_normal_groups(
self, mockauth):
'''
The showings_list_admin action returns a showing group created by the
user, but doesn't contains normal groups created by user.
'''
mockauth.return_value = True
showing_admin = factories.User()
factories.Group(user=showing_admin)
showing_group = factories.Group(type='showing', user=showing_admin)
showing_list = helpers.call_action('showings_list_admin',
context={'user': showing_admin})
assert len(showing_list) == 1
assert showing_list[0]['name'] == showing_group['name']
assert showing_list[0]['type'] == 'showing'
def test_group_show__deleted_group_is_visible_to_its_member(self):
fred = factories.User(name='fred')
org = factories.Group(users=[fred])
context = {'model': model}
context['user'] = '******'
ret = helpers.call_auth('group_show', context=context, id=org['name'])
assert ret
def test_group_show(self):
group = factories.Group(user=factories.User())
group_dict = helpers.call_action('group_show', id=group['id'])
# FIXME: Should this be returned by group_create?
group_dict.pop('num_followers', None)
assert group_dict == group
def test_about(self):
app = self._get_test_app()
user = factories.User()
group = factories.Group(user=user, type=custom_group_type)
group_name = group['name']
env = {'REMOTE_USER': user['name'].encode('ascii')}
url = url_for('%s_about' % custom_group_type, id=group_name)
response = app.get(url=url, extra_environ=env)
response.mustcontain(group_name)
def test_group_dictize_group_with_dataset(self):
group_ = factories.Group()
package = factories.Dataset(groups=[{'name': group_['name']}])
group_obj = model.Session.query(model.Group).filter_by().first()
context = {'model': model, 'session': model.Session}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(group['packages'][0]['name'], package['name'])
assert_equal(group['packages'][0]['groups'][0]['name'], group_['name'])
def test_group_show__deleted_group_is_hidden_to_public(self):
group = factories.Group(state='deleted')
context = {'model': model}
context['user'] = ''
assert_raises(logic.NotAuthorized,
helpers.call_auth,
'group_show',
context=context,
id=group['name'])
def test_group_list_dictize_including_extras(self):
factories.Group(extras=[{'key': 'k1', 'value': 'v1'}])
group_list = model.Session.query(model.Group).filter_by().all()
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(group_list,
context,
include_extras=True)
assert_equal(group_dicts[0]['extras'][0]['key'], 'k1')
def test_group_list_dictize_without_package_count(self):
group_ = factories.Group()
factories.Dataset(groups=[{'name': group_['name']}])
group_list = [model.Group.get(group_['name'])]
context = {'model': model, 'session': model.Session}
group_dicts = model_dictize.group_list_dictize(
group_list, context, with_package_counts=False)
assert 'packages' not in group_dicts[0]
def test_editors_and_admins_with_1_duplicate_admin(self):
'''Test editors_and_admins() with one user who is admin of two groups.
Should return a list with just the one user's ID.
'''
user = factories.User()
factories.Organization(user=user)
factories.Group(user=user)
assert plugin.editors_and_admins() == [user['id']]
def test_group_dictize(self):
group = factories.Group(name='test_dictize')
group_obj = model.Session.query(model.Group).filter_by().first()
context = {'model': model, 'session': model.Session}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(group['name'], 'test_dictize')
assert_equal(group['packages'], [])
assert_equal(group['extras'], [])
assert_equal(group['tags'], [])
assert_equal(group['groups'], [])
