def test_resource_update_with_missing_name(self):
'''If a user updates a resource and does not pass a name field, the
name should be changed to the name of the resource's uploaded file.
'''
user = factories.User()
dataset = factories.Dataset(user=user)
api = ckanapi.TestAppCKAN(self.app, apikey=user['apikey'])
resource = api.action.resource_create(
package_id=dataset['id'],
name='test-resource',
upload=custom_helpers.get_csv_file(
'test-data/lahmans-baseball-database/AllstarFull.csv'))
del resource['name']
helpers.call_action('resource_update', **resource)
resource = helpers.call_action('resource_show', id=resource['id'])
assert resource['name'] == 'AllstarFull.csv'
def test_not_authorized_if_user_has_no_permissions_on_dataset(self):
org = factories.Organization()
user = factories.User()
member = {'username': user['name'], 'role': 'admin', 'id': org['id']}
helpers.call_action('organization_member_create', **member)
user_2 = factories.User()
dataset = factories.Dataset(owner_org=org['id'])
context = {'user': user_2['name'], 'model': core_model}
nose.tools.assert_raises(logic.NotAuthorized,
helpers.call_auth,
'package_create_default_resource_views',
context=context,
package=dataset)
def test_reset_spam_state(self):
owner = factories.User()
org = factories.Organization(user=owner)
dataset = factories.Dataset(owner_org=org['name'])
issue = issue_factories.Issue(user_id=owner['id'],
dataset_id=dataset['id'],
spam_state='hidden',
spam_count='20')
context = {
'user': owner['name'],
'model': model,
}
helpers.call_action('issue_reset_spam_state',
context=context,
dataset_id=dataset['id'],
issue_id=issue['id'])
result = helpers.call_action('issue_show', id=issue['id'])
assert_equals(0, result['spam_count'])
assert_equals('visible', result['spam_state'])
def test_publisher_mark_spam(self):
owner = factories.User()
org = factories.Organization(user=owner)
dataset = factories.Dataset(owner_org=org['name'])
issue = issue_factories.Issue(user=owner,
user_id=owner['id'],
dataset_id=dataset['id'])
context = {
'user': owner['name'],
'model': model,
}
helpers.call_action('issue_report_spam',
context=context,
dataset_id=dataset['id'],
issue_id=issue['id'])
result = helpers.call_action('issue_show', id=issue['id'])
assert_equals('hidden', result['spam_state'])
def test_increase_spam(self):
owner = factories.User()
org = factories.Organization(user=owner)
dataset = factories.Dataset(owner_org=org['name'])
issue = issue_factories.Issue(user_id=owner['id'],
dataset_id=dataset['id'])
user = factories.User(name='unauthed')
context = {
'user': user['name'],
'model': model,
}
helpers.call_action('issue_report_spam',
context=context,
dataset_id=dataset['id'],
issue_id=issue['id'])
result = helpers.call_action('issue_show', id=issue['id'])
assert_equals(1, result['spam_count'])
def test_resource_schema_field_create_return_value(self):
'''resource_schema_field_create should return the field that was
created.
'''
resource = factories.Resource(dataset=factories.Dataset())
field = helpers.call_action('resource_schema_field_create',
resource_id=resource['id'],
index=0,
name='name',
title='title',
description='description',
type='string',
format='format')
assert field == helpers.call_action('resource_schema_field_show',
resource_id=resource['id'],
index=0)
def test_create_comment_on_issue(self):
user = factories.User()
dataset = factories.Dataset()
issue = issue_factories.Issue(user=user,
user_id=user['id'],
dataset_id=dataset['id'])
helpers.call_action('issue_comment_create',
context={'user': user['name']},
issue_id=issue['id'],
comment='some comment')
result = helpers.call_action('issue_show',
context={'user': user['name']},
id=issue['id'])
comments = result['comments']
assert_equals(len(comments), 1)
assert_equals(comments[0]['comment'], 'some comment')
def test_extra_gets_deleted_on_extra_only_update(self):
dataset = factories.Dataset()
resource = factories.Resource(package=dataset,
url='http://first',
newfield='first')
res_returned = helpers.call_action('resource_update',
id=resource['id'],
url='http://first',
anotherfield='second')
assert_equals(res_returned['url'], 'http://first')
assert_equals(res_returned['anotherfield'], 'second')
assert 'newfield' not in res_returned
resource = helpers.call_action('resource_show', id=resource['id'])
assert_equals(res_returned['url'], 'http://first')
assert_equals(res_returned['anotherfield'], 'second')
assert 'newfield' not in res_returned
def test_edit_custom_extra_field(self):
# i.e. an extra field that is not mentioned in the schema, filled in on
# the form in the 'custom-fields' section
dataset = factories.Dataset(extras=[{
'key': 'testkey',
'value': 'foo'
}])
app = self._get_test_app()
env, response = _get_package_edit_page(app, dataset['name'])
form = response.forms['dataset-edit']
form['extras__0__value'] = u'bar'
response = submit_and_follow(app, form, env, 'save')
# just check it has finished the edit, rather than being sent on to the
# resource create/edit form.
assert_equal(response.req.path, '/dataset/%s' % dataset['name'])
pkg = model.Package.by_name(dataset['name'])
assert_equal(pkg.extras['testkey'], u'bar')
def test_resource_schema_field_create_with_nonconsecutive_indices(self):
'''Test creating a field with index 3, when no fields with indexes
0, 1 or 2 exist yet.
'''
resource = factories.Resource(dataset=factories.Dataset())
helpers.call_action('resource_schema_field_create',
resource_id=resource['id'],
index=3,
name='foo')
schema = helpers.call_action('resource_schema_show',
resource_id=resource['id'])
assert 'fields' in schema
fields = schema['fields']
assert len(fields) == 1
field = fields[0]
assert field == {'index': 3, 'name': 'foo'}
def test_resource_with_no_file(self):
'''When viewing the page of a resource that has a remote URL instead of
an uploaded file, a 'No such file or directory' error should be shown
instead of the CSV preview.
'''
dataset = factories.Dataset()
resource = factories.Resource(dataset=dataset)
response = self.app.get(
toolkit.url_for(controller='package', action='resource_read',
id=dataset['id'], resource_id=resource['id']))
soup = response.html
divs = soup('div', class_='ckanext-datapreview')
assert len(divs) == 1
div = divs[0]
assert div.text.strip() == ("Error: There's no uploaded file for this "
"resource")
def setup(self):
super(TestModeratedAbuseReport, self).setup()
self.owner = factories.User()
self.reporter = factories.User()
self.org = factories.Organization(user=self.owner)
self.dataset = factories.Dataset(user=self.owner,
owner_org=self.org['name'])
# issue_abuse is moderated - i.e. definitely abuse/spam
self.issue_abuse = issue_factories.Issue(user=self.owner,
user_id=self.owner['id'],
dataset_id=self.dataset['id'])
issue_abuse = Issue.get(self.issue_abuse['id'])
issue_abuse.visibility = 'hidden'
issue_abuse.report_abuse(model.Session, self.reporter['id'])
issue_abuse.abuse_status = AbuseStatus.abuse.value
issue_abuse.save()
self.user = factories.User()
self.app = self._get_test_app()
def test_user_cannot_edit_another_users_issue(self):
owner = factories.User()
user = factories.User()
org = factories.Organization(user=owner)
dataset = factories.Dataset(user=owner, owner_org=org['name'])
issue = issue_factories.Issue(user=owner, dataset_id=dataset['id'])
app = self._get_test_app()
env = {'REMOTE_USER': user['name'].encode('ascii')}
response = app.post(
url=toolkit.url_for('issues_edit',
package_id=dataset['id'],
id=issue['id']),
params={'title': 'edit', 'description': 'edited description'},
extra_environ=env,
expect_errors=True
)
assert_equals(response.status_int, 401)
def test_spatial_extra(self):
''' '''
app = self._get_test_app()
user = factories.User()
env = {u'REMOTE_USER': user[u'name'].encode(u'ascii')}
dataset = factories.Dataset(user=user)
offset = toolkit.url_for(controller=u'package',
action=u'edit',
id=dataset[u'id'])
res = app.get(offset, extra_environ=env)
form = res.forms[1]
form[u'extras__0__key'] = u'spatial'
form[u'extras__0__value'] = self.geojson_examples[u'point']
res = helpers.submit_and_follow(app, form, env, u'save')
assert u'Error' not in res, res
package_extent = Session.query(PackageExtent) \
.filter(PackageExtent.package_id == dataset[u'id']).first()
geojson = json.loads(self.geojson_examples[u'point'])
assert_equals(package_extent.package_id, dataset[u'id'])
if legacy_geoalchemy:
assert_equals(Session.scalar(package_extent.the_geom.x),
geojson[u'coordinates'][0])
assert_equals(Session.scalar(package_extent.the_geom.y),
geojson[u'coordinates'][1])
assert_equals(Session.scalar(package_extent.the_geom.srid),
self.db_srid)
else:
from sqlalchemy import func
assert_equals(
Session.query(func.ST_X(package_extent.the_geom)).first()[0],
geojson[u'coordinates'][0])
assert_equals(
Session.query(func.ST_Y(package_extent.the_geom)).first()[0],
geojson[u'coordinates'][1])
assert_equals(package_extent.the_geom.srid, self.db_srid)
def test_default_views_created_on_package_update(self):
dataset_dict = factories.Dataset(resources=[{
'url': 'http://not.for.viewing',
'format': 'xxx',
}])
resource_id = dataset_dict['resources'][0]['id']
views_list = helpers.call_action('resource_view_list', id=resource_id)
eq_(len(views_list), 0)
updated_data_dict = {
'id':
dataset_dict['id'],
'resources': [
{
'url': 'http://not.for.viewing',
'format': 'xxx',
},
{
'url': 'http://some.image.png',
'format': 'png',
},
]
}
dataset_dict = helpers.call_action('package_update',
**updated_data_dict)
for resource in dataset_dict['resources']:
resource_id = resource['id'] if resource[
'format'] == 'PNG' else None
assert resource_id
updated_views_list = helpers.call_action('resource_view_list',
id=resource_id)
eq_(len(updated_views_list), 1)
eq_(updated_views_list[0]['view_type'], 'image_view')
pass
def test_spatial_extra_bad_geojson(self):
app = self._get_test_app()
user = factories.User()
env = {'REMOTE_USER': user['name'].encode('ascii')}
dataset = factories.Dataset(user=user)
offset = url_for(controller='package', action='edit', id=dataset['id'])
res = app.get(offset, extra_environ=env)
form = res.forms[1]
form['extras__0__key'] = u'spatial'
form['extras__0__value'] = u'{"Type":"Bad_GeoJSON","a":2}'
res = helpers.webtest_submit(form, extra_environ=env, name='save')
assert 'Error' in res, res
assert 'Spatial' in res
assert 'Error creating geometry' in res
def test_package_patch_updating_single_field(self):
user = factories.User()
dataset = factories.Dataset(
name='annakarenina',
notes='some test now',
user=user)
dataset = helpers.call_action(
'package_patch',
id=dataset['id'],
name='somethingnew')
assert_equals(dataset['name'], 'somethingnew')
assert_equals(dataset['notes'], 'some test now')
dataset2 = helpers.call_action('package_show', id=dataset['id'])
assert_equals(dataset2['name'], 'somethingnew')
assert_equals(dataset2['notes'], 'some test now')
def test_resource_update(self):
'''Test that a resource's schema is updated when the resource is
updated with a new uploaded CSV file.
Unit tests elsewhere test that the schemas inferred from CSV files are
correct, here we're just testing that the schema gets added to the
resource on resource_create().
'''
user = factories.Sysadmin()
package = factories.Dataset(user=user)
api = ckanapi.TestAppCKAN(self.app, apikey=user['apikey'])
# Upload a first CSV file to the package.
csv_file = custom_helpers.get_csv_file(
'test-data/lahmans-baseball-database/AllstarFull.csv')
api.action.resource_create(package_id=package['id'],
name='test-package',
upload=csv_file)
# Get the generated schema from the resource.
package = api.action.package_show(id=package['id'])
assert len(package['resources']) == 1
resource = package['resources'][0]
assert 'schema' in resource
original_schema = resource['schema']
# Now update the resource with a new file.
csv_file = custom_helpers.get_csv_file(
'test-data/lahmans-baseball-database/Appearances.csv')
api.action.resource_update(id=resource['id'],
name=resource['name'],
upload=csv_file)
# Check that the schema has been changed.
package = api.action.package_show(id=package['id'])
assert len(package['resources']) == 1
resource = package['resources'][0]
assert 'schema' in resource
schema = resource['schema']
assert 'fields' in schema
assert schema != original_schema
def test_normal_user_cannot_update_issue(self):
issue_owner = factories.User()
org = factories.Organization()
dataset = factories.Dataset(owner_org=org['name'])
issue = issue_factories.Issue(user=issue_owner,
user_id=issue_owner['id'],
dataset_id=dataset['id'])
other_user = factories.User()
context = {
'user': other_user['name'],
'model': model,
}
assert_raises(toolkit.NotAuthorized,
helpers.call_auth,
'issue_update',
context,
id=issue['id'],
dataset_id=dataset['id'],
status='open')
def test_org_editor_can_update_an_issue(self):
org_editor = factories.User()
org = factories.Organization()
helpers.call_action('member_create',
object=org_editor['name'],
id=org['id'],
object_type='user',
capacity='editor')
dataset = factories.Dataset(owner_org=org['name'], private=True)
user = helpers.call_action('get_site_user')
issue = issue_factories.Issue(user=user, dataset_id=dataset['id'])
context = {
'user': org_editor['name'],
'model': model,
}
assert_true(
helpers.call_auth('issue_update',
context,
dataset_id=dataset['id']))
def test_group_dictize_with_package_list_limited_over(self):
'''
Packages limit is set higher than number of packages in group.
'''
group_ = factories.Group()
for _ in range(3):
factories.Dataset(groups=[{'name': group_['name']}])
group_obj = model.Session.query(model.Group).filter_by().first()
# limit packages to 4
context = {
'model': model,
'session': model.Session,
'limits': {
'packages': 4
}
}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(len(group['packages']), 3)
def test_authorized_if_user_has_permissions_on_dataset(self):
user = factories.User()
dataset = factories.Dataset(user=user)
resource = factories.Resource(user=user, package_id=dataset['id'])
resource_view = {
'resource_id': resource['id'],
'title': u'Resource View',
'view_type': u'image_view',
'image_url': 'url'
}
context = {'user': user['name'], 'model': core_model}
response = helpers.call_auth('resource_view_create',
context=context,
**resource_view)
assert_equals(response, True)
def test_resource_schema_field_update_with_invalid_type(self):
'''Updating a field with an invalid type should raise ValidationError.
'''
resource = factories.Resource(dataset=factories.Dataset())
field = helpers.call_action('resource_schema_field_create',
resource_id=resource['id'],
index=0,
name='foo',
type='string')
for type_ in (False, 1, 2.0, [], {}, '', 'foo', [1, 2, 3], {
'foo': 'bar'
}):
field['type'] = type_
nose.tools.assert_raises(toolkit.ValidationError,
helpers.call_action,
'resource_schema_field_update',
resource_id=resource['id'],
**field)
def test_org_editor_can_update_an_issue(self):
org_editor = factories.User()
org = factories.Organization(users=[{
'name': org_editor['id'],
'capacity': 'editor'
}])
dataset = factories.Dataset(owner_org=org['name'], private=True)
user = helpers.call_action('get_site_user')
issue = issue_factories.Issue(user=user, dataset_id=dataset['id'])
context = {
'user': org_editor['name'],
'model': model,
}
assert_true(
helpers.call_auth('issue_update',
context,
issue_number=issue['number'],
dataset_id=dataset['id'],
status='open'))
def test_create_index_on_specific_fields(self):
package = factories.Dataset()
data = {
'resource': {
'boo%k': 'crime',
'author': ['tolstoy', 'dostoevsky'],
'package_id': package['id']
},
'fields': [{
'id': 'book',
'type': 'text'
}, {
'id': 'author',
'type': 'text'
}],
'indexes': ['author']
}
result = helpers.call_action('datastore_create', **data)
resource_id = result['resource_id']
assert self._has_index_on_field(resource_id, '"author"')
def test_create_adds_index_on_full_text_search_when_not_creating_other_indexes(
self):
package = factories.Dataset()
data = {
'resource': {
'boo%k': 'crime',
'author': ['tolstoy', 'dostoevsky'],
'package_id': package['id']
},
'fields': [{
'id': 'book',
'type': 'text'
}, {
'id': 'author',
'type': 'text'
}],
}
result = helpers.call_action('datastore_create', **data)
resource_id = result['resource_id']
assert self._has_index_on_field(resource_id, '"_full_text"')
def test_resource_controller_plugin_create(self):
user = factories.Sysadmin()
package = factories.Dataset(user=user)
# Set up the plugin
ckan.plugins.load('example_iresourcecontroller')
plugin = ckan.plugins.get_plugin('example_iresourcecontroller')
res = helpers.call_action('resource_create',
package_id=package['id'],
name='test-resource',
url='http://resource.create/',
apikey=user['apikey'])
assert plugin.counter['before_create'] == 1, plugin.counter
assert plugin.counter['after_create'] == 1, plugin.counter
assert plugin.counter['before_update'] == 0, plugin.counter
assert plugin.counter['after_update'] == 0, plugin.counter
assert plugin.counter['before_delete'] == 0, plugin.counter
assert plugin.counter['after_delete'] == 0, plugin.counter
def test_group_dictize_with_package_list_limited(self):
'''
Packages returned in group are limited by context var.
'''
group_ = factories.Group()
for _ in range(10):
factories.Dataset(groups=[{'name': group_['name']}])
group_obj = model.Session.query(model.Group).filter_by().first()
# limit packages to 4
context = {
'model': model,
'session': model.Session,
'limits': {
'packages': 4
}
}
group = model_dictize.group_dictize(group_obj, context)
assert_equal(len(group['packages']), 4)
def test_resource_update_with_custom_format(self):
'''If a format other than CSV is given when updating a resource, it
should be accepted.
'''
user = factories.User()
dataset = factories.Dataset(user=user)
api = ckanapi.TestAppCKAN(self.app, apikey=user['apikey'])
resource = api.action.resource_create(
package_id=dataset['id'],
upload=custom_helpers.get_csv_file(
'test-data/lahmans-baseball-database/AllstarFull.csv'))
for format_ in ('jpeg', 'image/png', 'foobar'):
resource = api.action.resource_update(id=resource['id'],
format=format_,
url=resource['url'])
resource = api.action.resource_show(id=resource['id'])
assert resource['format'] == format_
def test_resource_schema_field_create_with_string_int_as_index(self):
'''If an integer in a string (like "1") is passed as the index
parameter to resource_schema_field_create it should be converted to
an int and used.
'''
resource = factories.Resource(dataset=factories.Dataset())
helpers.call_action('resource_schema_field_create',
resource_id=resource['id'],
index='0',
name='foo')
schema = helpers.call_action('resource_schema_show',
resource_id=resource['id'])
assert 'fields' in schema
fields = schema['fields']
assert len(fields) == 1
field = fields[0]
assert field == {'index': 0, 'name': 'foo'}
