def setup_class(cls):
MockPackageSearchPlugin().activate()
MockPackageSearchPlugin().enable()
setup_test_search_index()
CreateTestData.create()
MockPackageSearchPlugin().disable()
cls.sysadmin_user = model.User.get('testsysadmin')
def setup_class(cls):
"""Setup for all tests."""
model.repo.rebuild_db()
kata_model.setup()
CreateTestData.create()
cls.user_sysadmin = model.User.get('testsysadmin') # Org admin
cls.user_normal = model.User.get('tester') # Org editor
cls.user_anna = model.User.get('annafan')
cls.user_joe = model.User.get('joeadmin') # Org member
wsgiapp = make_app(config['global_conf'], **config['app_conf'])
cls.app = paste.fixture.TestApp(wsgiapp)
# Set up API callers
cls.api_user_normal = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_normal.apikey)
cls.api_user_sysadmin = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_sysadmin.apikey)
cls.api_user_anna = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_anna.apikey)
cls.api_user_joe = ckanapi.TestAppCKAN(cls.app, apikey=cls.user_joe.apikey)
cls.api = ckanapi.TestAppCKAN(cls.app)
cls.TEST_DATADICT = copy.deepcopy(TEST_DATADICT)
try:
output = cls.api_user_sysadmin.action.organization_create(**TEST_ORGANIZATION_COMMON)
cls.TEST_DATADICT['owner_org'] = output.get('id')
except AppError:
print 'Failed to create a common organization. Perhaps it exists already.'
def setup_class(self):
CreateTestData.create()
self.ab = 'http://site.com/a/b.txt'
self.cd = 'http://site.com/c/d.txt'
self.package_fixture_data = {
'name' : u'testpkg',
'title': 'Some Title',
'url': u'http://blahblahblah.mydomain',
'resources':[
{'url':self.ab,
'description':'This is site ab.',
'format':'Excel spreadsheet',
'alt_url':'alt',
'extras':{'size':'100'},
'hash':'abc-123'},
{'url':self.cd,
'description':'This is site cd.',
'format':'Office spreadsheet',
'alt_url':'alt',
'extras':{'size':'100'},
'hash':'qwe-456'},
],
'tags': ['russion', 'novel'],
'license_id': u'gpl-3.0',
'extras': {'national_statistic':'yes',
'geographic_coverage':'England, Wales'},
}
CreateTestData.create_arbitrary(self.package_fixture_data)
self.base_url = self.offset('/search/resource')
def setup_class(cls):
harvest_model.setup()
CreateTestData.create()
sysadmin_user = ckan.model.User.get('testsysadmin')
cls.sysadmin = {
'id': sysadmin_user.id,
'apikey': sysadmin_user.apikey,
'name': sysadmin_user.name,
}
cls.app = paste.fixture.TestApp(pylons.test.pylonsapp)
cls.default_source_dict = {
"url": "http://test.action.com",
"name": "test-source-action",
"title": "Test source action",
"notes": "Test source action desc",
"source_type": "test-for-action",
"frequency": "MANUAL",
"config": json.dumps({"custom_option":["a","b"]})
}
if not p.plugin_loaded('test_action_harvester'):
p.load('test_action_harvester')
def setup(self):
# need to do this for every test since we mess with System rights
CreateTestData.create()
model.repo.new_revision()
model.Session.add(model.User(name=u'testadmin'))
model.Session.add(model.User(name=u'testsysadmin'))
model.Session.add(model.User(name=u'notadmin'))
model.repo.commit_and_remove()
pkg = model.Package.by_name(u'annakarenina')
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(sysadmin, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
self.pkg = model.Package.by_name(u'annakarenina')
self.admin = model.User.by_name(u'testadmin')
self.sysadmin = model.User.by_name(u'testsysadmin')
self.notadmin = model.User.by_name(u'notadmin')
self.package_fillers = {'title': 'test title',
'notes': 'test notes',
'license_id': 'mit-license',
}
def setup_class(cls):
search.clear_all()
CreateTestData.create()
cls.testsysadmin = model.User.by_name(u'testsysadmin')
cls.comment = u'Comment umlaut: \xfc.'
cls.user_name = u'annafan' # created in CreateTestData
cls.init_extra_environ(cls.user_name)
def setup_class(self):
# create test data
CreateTestData.create()
username = '******'
user = model.User.by_name(unicode(username))
assert user
self.testclient = WsgiCkanClient(self.app, api_key=user.apikey, base_location='/api/2')
def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.name = u"revisiontest1"
# create pkg
self.description = [
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)
self.grp.description = self.description[0]
model.Session.add(self.grp)
model.setup_default_user_roles(self.grp)
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.description[i]
model.repo.commit_and_remove()
self.grp = model.Group.by_name(self.name)
def setup_class(cls):
MockVocabTagsPlugin().set_active(True)
CreateTestData.create(package_type='mock_vocab_tags_plugin')
cls.sysadmin_user = model.User.get('testsysadmin')
cls.dset = model.Package.get('warandpeace')
cls.tag1_name = 'vocab-tag-1'
cls.tag2_name = 'vocab-tag-2'
# use our custom select class for this test suite
cls.old_select = paste.fixture.Field.classes['select']
paste.fixture.Field.classes['select'] = Select
# create a test vocab
params = json.dumps({'name': TEST_VOCAB_NAME})
extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
response = cls.app.post('/api/action/vocabulary_create', params=params,
extra_environ=extra_environ)
assert json.loads(response.body)['success']
vocab_id = json.loads(response.body)['result']['id']
# add tags to the vocab
extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
params = json.dumps({'name': cls.tag1_name, 'vocabulary_id': vocab_id})
response = cls.app.post('/api/action/tag_create', params=params,
extra_environ=extra_environ)
assert json.loads(response.body)['success']
params = json.dumps({'name': cls.tag2_name, 'vocabulary_id': vocab_id})
response = cls.app.post('/api/action/tag_create', params=params,
extra_environ=extra_environ)
assert json.loads(response.body)['success']
def setup_class(cls):
model.repo.rebuild_db()
search.clear_all()
CreateTestData.create()
cls.sysadmin_user = model.User.get('testsysadmin')
cls.normal_user = model.User.get('annafan')
CreateTestData.make_some_vocab_tags()
def setup_class(cls):
search.clear()
CreateTestData.create()
cls.testsysadmin = model.User.by_name(u"testsysadmin")
cls.comment = u"Comment umlaut: \xfc."
cls.user_name = u"annafan" # created in CreateTestData
cls.init_extra_environ(cls.user_name)
def _reset_data(self):
model.Session.remove()
model.repo.rebuild_db()
CreateTestData.create()
CreateTestData.create_arbitrary(
{'name':self.editpkg_name,
'url':u'editpkgurl.com',
'tags':[u'mytesttag'],
'resources':[{'url':u'url escape: & umlaut: \xfc quote: "',
'description':u'description escape: & umlaut: \xfc quote "',
}],
'admins':[u'testadmin'],
})
self.editpkg = model.Package.by_name(self.editpkg_name)
self.pkgid = self.editpkg.id
self.offset = url_for(controller='package', action='edit', id=self.editpkg_name)
self.editpkg = model.Package.by_name(self.editpkg_name)
self.admin = model.User.by_name(u'testsysadmin')
self.extra_environ_admin = {'REMOTE_USER': self.admin.name.encode('utf8')}
self.extra_environ_russianfan = {'REMOTE_USER': '******'}
self.res = None #get's refreshed by setup
model.Session.remove()
def setup_class(cls):
model.repo.rebuild_db()
CreateTestData.create()
plugins.load('drupal')
from ckan.plugins import PluginImplementations
from ckan.plugins.interfaces import IConfigurer
for plugin in PluginImplementations(IConfigurer):
plugin.update_config(config)
url = config['drupal.db_url']
cls.engine = create_engine(url, echo=True)
cls.metadata = MetaData(cls.engine)
cls.node = Table('node',
cls.metadata,
autoload = True)
cls.node = Table('node_revisions',
cls.metadata,
autoload = True)
cls.package_table = Table('ckan_package',
cls.metadata,
autoload = True)
cls.extra_table = Table('ckan_package_extra',
cls.metadata,
autoload = True)
cls.resource_table = Table('ckan_resource',
cls.metadata,
autoload = True)
cls.engine.execute('delete from ckan_package')
cls.engine.execute('delete from ckan_resource')
cls.engine.execute('delete from ckan_package_extra')
cls.engine.execute('delete from ckan_package_tag')
cls.engine.execute('delete from node')
cls.engine.execute('delete from node_revisions')
def setup(cls):
CreateTestData.create()
for ag_name in [u'anauthzgroup', u'anotherauthzgroup']:
ag=model.AuthorizationGroup.by_name(ag_name)
if not ag: #may already exist, if not create
ag=model.AuthorizationGroup(name=ag_name)
model.Session.add(ag)
model.Session.commit()
def setup_class(cls):
CreateTestData.create()
cls._original_config = config.copy()
wsgiapp = ckan.config.middleware.make_app(config['global_conf'],
**config)
cls.app = paste.fixture.TestApp(wsgiapp)
cls.sysadmin_user = model.User.get('testsysadmin')
PylonsTestCase.setup_class()
def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(self):
try:
CreateTestData.delete()
except:
pass
model.repo.init_db()
model.Session.remove()
CreateTestData.create()
def setup_class(cls):
CreateTestData.create()
cls._original_config = config.copy()
wsgiapp = ckan.config.middleware.make_app(
config['global_conf'], **config)
cls.app = paste.fixture.TestApp(wsgiapp)
cls.sysadmin_user = model.User.get('testsysadmin')
PylonsTestCase.setup_class()
def setup_class(cls):
cls.db = ManageDb('db')
CreateTestData.create()
# delete warandpeace
rev = model.repo.new_revision()
model.Package.by_name(u'warandpeace').delete()
model.repo.commit_and_remove()
def initial_data(self):
# clean the db so we can run these tests on their own
model.repo.rebuild_db()
search.clear_all()
CreateTestData.create()
yield
model.repo.rebuild_db()
model.Session.remove()
def setup_class(self):
search.clear()
model.Session.remove()
CreateTestData.create()
# reduce extraneous logging
from ckan.lib import activity_streams_session_extension
activity_streams_session_extension.logger.level = 100
def setup_class(cls):
search.clear()
CreateTestData.create()
cls.sysadmin_user = model.User.get("testsysadmin")
cls.sysadmin_action = TestAppCKAN(cls.app, str(cls.sysadmin_user.apikey)).action
cls.example_pkg = [json.loads(j) for j in EXAMPLE_JSON_LINES.strip().split("\n")]
def setup_class(cls):
cls.db = ManageDb('db')
CreateTestData.create()
# delete warandpeace
rev = model.repo.new_revision()
model.Package.by_name(u'warandpeace').delete()
model.repo.commit_and_remove()
def setup_class(cls):
"""Set up testing environment."""
kata_model.setup()
CreateTestData.create()
wsgiapp = make_app(config['global_conf'], **config['app_conf'])
cls.app = paste.fixture.TestApp(wsgiapp)
def setup_class(self):
search.clear_all()
model.Session.remove()
CreateTestData.create()
# reduce extraneous logging
from ckan.lib import activity_streams_session_extension
activity_streams_session_extension.logger.level = 100
def setup_class(self):
model.Session.remove()
CreateTestData.create()
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(cls):
CreateTestData.create()
cls._original_config = config.copy()
config['ckan.auth.create_user_via_web'] = True
wsgiapp = ckan.config.middleware.make_app(
config['global_conf'], **config)
cls.app = helpers._get_test_app()
cls.sysadmin_user = model.User.get('testsysadmin')
PylonsTestCase.setup_class()
def setup_class(self):
setup_test_search_index()
model.Session.remove()
CreateTestData.create()
self.groupname = u'david'
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(self):
model.repo.init_db()
CreateTestData.create()
CreateTestData.create_test_user()
self.admin = model.User.by_name(u'testsysadmin')
self.extra_environ_admin = {'REMOTE_USER': self.admin.name.encode('utf8')}
self.extra_environ_tester = {'REMOTE_USER': '******'}
def setup_class(self):
setup_test_search_index()
model.Session.remove()
CreateTestData.create()
self.groupname = u'david'
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(self):
# create test data
CreateTestData.create()
username = '******'
user = model.User.by_name(unicode(username))
assert user
self.testclient = WsgiCkanClient(self.app,
api_key=user.apikey,
base_location='/api/2')
def setup_class(cls):
cls.username = '******'
cls.groupname = 'david'
model.repo.new_revision()
CreateTestData.create()
cls.pkgs = [
model.Package.by_name('warandpeace'),
model.Package.by_name('annakarenina'),
]
def setup_class(cls):
CreateTestData.create()
cls._original_config = config.copy()
config['ckan.auth.create_user_via_web'] = True
new_authz.clear_auth_functions_cache()
wsgiapp = ckan.config.middleware.make_app(
config['global_conf'], **config)
cls.app = paste.fixture.TestApp(wsgiapp)
cls.sysadmin_user = model.User.get('testsysadmin')
PylonsTestCase.setup_class()
def setup_class(cls):
CreateTestData.create()
cls._original_config = config.copy()
config['ckan.auth.create_user_via_web'] = True
new_authz.clear_auth_functions_cache()
wsgiapp = ckan.config.middleware.make_app(config['global_conf'],
**config)
cls.app = paste.fixture.TestApp(wsgiapp)
cls.sysadmin_user = model.User.get('testsysadmin')
PylonsTestCase.setup_class()
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 setup_class(cls):
search.clear()
CreateTestData.create()
cls.sysadmin_user = model.User.get('testsysadmin')
cls.sysadmin_action = TestAppCKAN(cls.app,
str(cls.sysadmin_user.apikey)).action
cls.example_pkg = [
json.loads(j) for j in EXAMPLE_JSON_LINES.strip().split('\n')
]
def setup_class(self):
from ckan.tests.mock_publisher_auth import MockPublisherAuth
self.auth = MockPublisherAuth()
model.Session.remove()
CreateTestData.create(auth_profile='publisher')
self.groupname = u'david'
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(self):
from ckan.tests.mock_publisher_auth import MockPublisherAuth
self.auth = MockPublisherAuth()
model.Session.remove()
CreateTestData.create(auth_profile='publisher')
self.groupname = u'david'
self.packagename = u'testpkg'
model.repo.new_revision()
model.Session.add(model.Package(name=self.packagename))
model.repo.commit_and_remove()
def setup_class(cls):
search.clear()
CreateTestData.create()
cls.sysadmin_user = model.User.get('testsysadmin')
cls.normal_user = model.User.get('annafan')
cls.publisher_user = model.User.get('russianfan')
cls.sysadmin_action = TestAppCKAN(cls.app,
str(cls.sysadmin_user.apikey)).action
cls.normal_action = TestAppCKAN(cls.app,
str(cls.normal_user.apikey)).action
cls.publisher_action = TestAppCKAN(
cls.app, str(cls.publisher_user.apikey)).action
cls.action = TestAppCKAN(cls.app).action
cls.sysadmin_action.organization_member_create(username='******',
id='nrcan-rncan',
role='editor')
cls.sysadmin_action.organization_member_create(username='******',
id='tb-ct',
role='editor')
cls.incomplete_pkg = {
'title':
u'A Novel By Tolstoy',
'license_id':
'ca-ogl-lgo',
'resources': [{
'name': u'Full text.',
'name_fra': u'Full text.',
'format': u'TXT',
'url': u'http://www.annakarenina.com/download/',
'size': 42,
'resource_type': 'file',
'language': 'zxx; CAN',
}],
}
cls.override_possible_pkg = dict(cls.incomplete_pkg,
owner_org='nrcan-rncan')
cls.complete_pkg = dict(
cls.override_possible_pkg,
catalog_type=u'Data | Données',
title_fra=u'Un novel par Tolstoy',
maintenance_and_update_frequency=u'As Needed | Au besoin',
notes=u'...',
notes_fra=u'...',
subject=[u'Persons Personnes'],
date_published=u'2013-01-01',
keywords=u'book',
keywords_fra=u'livre')
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_package_to_api2(self):
CreateTestData.create()
context = {"model": model, "session": model.Session}
pkg = model.Package.get("annakarenina")
as_dict = pkg.as_dict(ref_package_by="id", ref_group_by="id")
dictize = package_to_api2(pkg, context)
as_dict_string = pformat(as_dict)
dictize_string = pformat(dictize)
assert package_to_api2(pkg, context) == dictize, "\n".join(
unified_diff(as_dict_string.split("\n"),
dictize_string.split("\n")))
def test_tag_autocomplete(self):
CreateTestData.create()
url = url_for(controller='api', action='tag_autocomplete')
assert_equal(url, '/api/2/util/tag/autocomplete')
response = self.app.get(
url=url,
params={
'incomplete': u'ru',
},
status=200,
)
assert_equal(response.body, '{"ResultSet": {"Result": [{"Name": "russian"}]}}')
assert_equal(response.header('Content-Type'), 'application/json;charset=utf-8')
def test_package_to_api1(self):
CreateTestData.create()
context = {"model": model, "session": model.Session}
pkg = model.Package.get("annakarenina")
asdict = pkg.as_dict()
asdict["download_url"] = asdict["resources"][0]["url"]
asdict["license_title"] = u"Other (Open)"
asdict["num_tags"] = 3
asdict["num_resources"] = 2
dictize = package_to_api1(pkg, context)
# the is_dict method doesn't care about organizations
del dictize["organization"]
assert dictize == asdict
def test_get_pkg_dict_extra(self):
from ckan.lib.create_test_data import CreateTestData
from ckan import model
from ckan.logic import get_action
CreateTestData.create()
pkg_dict = get_action('package_show')({'model': model, 'user': u'tester'}, {'id': 'annakarenina'})
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'genre'), '"romantic novel"')
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'extra_not_found'), None)
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'extra_not_found', 'default_value'), 'default_value')
def test_get_pkg_dict_extra(self):
from ckan.lib.create_test_data import CreateTestData
from ckan import model
from ckan.logic import get_action
CreateTestData.create()
pkg_dict = get_action("package_show")({"model": model, "user": u"tester"}, {"id": "annakarenina"})
assert_equal(h.get_pkg_dict_extra(pkg_dict, "genre"), "romantic novel")
assert_equal(h.get_pkg_dict_extra(pkg_dict, "extra_not_found"), None)
assert_equal(h.get_pkg_dict_extra(pkg_dict, "extra_not_found", "default_value"), "default_value")
def initial_data(self, clean_db):
CreateTestData.create()
pkg = model.Package(name=self.non_active_name)
model.Session.add(pkg)
model.repo.commit_and_remove()
pkg = (model.Session.query(
model.Package).filter_by(name=self.non_active_name).one())
admin = model.User.by_name(u"joeadmin")
model.repo.commit_and_remove()
pkg = (model.Session.query(
model.Package).filter_by(name=self.non_active_name).one())
pkg.delete() # becomes non active
model.repo.commit_and_remove()
def setup_class(cls):
CreateTestData.create()
cls.tester_user = model.User.by_name(u'tester')
cls.extra_environ_admin = {'REMOTE_USER': '******'}
cls.extra_environ_tester = {'REMOTE_USER': '******'}
cls.extra_environ_someone_else = {'REMOTE_USER': '******'}
tests.call_action_api(cls.app, 'organization_create',
name='test_org_2',
apikey=cls.tester_user.apikey)
tests.call_action_api(cls.app, 'package_create',
name='crimeandpunishment',
owner_org='test_org_2',
apikey=cls.tester_user.apikey)
def setup_class(self):
CreateTestData.create()
self.non_active_name = u'test_nonactive'
pkg = model.Package(name=self.non_active_name)
model.repo.new_revision()
model.Session.add(pkg)
model.repo.commit_and_remove()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
admin = model.User.by_name(u'joeadmin')
model.repo.commit_and_remove()
model.repo.new_revision()
pkg = model.Session.query(model.Package).filter_by(name=self.non_active_name).one()
pkg.delete() # becomes non active
model.repo.commit_and_remove()
def initial_data(self, clean_db, app):
CreateTestData.create()
users = {}
tester = model.User.by_name(u"tester")
tests.call_action_api(app,
"organization_create",
name="test_org_2",
apikey=tester.apikey)
tests.call_action_api(
app,
"package_create",
name="crimeandpunishment",
owner_org="test_org_2",
apikey=tester.apikey,
)
def test_tag_autocomplete(self):
CreateTestData.create()
url = url_for(controller='api', action='tag_autocomplete')
assert_equal(url, '/api/2/util/tag/autocomplete')
response = self.app.get(
url=url,
params={
'incomplete': u'ru',
},
status=200,
)
assert_equal(response.body,
'{"ResultSet": {"Result": [{"Name": "russian"}]}}')
assert_equal(response.header('Content-Type'),
'application/json;charset=utf-8')
def test_table_simple_save(self):
CreateTestData.create()
context = {"model": model, "session": model.Session}
anna1 = model.Package.get("annakarenina")
anna_dictized = self.remove_changable_columns(
table_dictize(anna1, context))
anna_dictized["name"] = "annakarenina2"
table_dict_save(anna_dictized, model.Package, context)
model.Session.commit()
pkg = model.Package.get("annakarenina2")
assert (self.remove_changable_columns(table_dictize(
pkg, context)) == anna_dictized), self.remove_changable_columns(
table_dictize(pkg, context))
def test_get_pkg_dict_extra(self):
from ckan.lib.create_test_data import CreateTestData
from ckan import model
from ckan.logic import get_action
CreateTestData.create()
pkg_dict = get_action('package_show')({'model': model, 'user': u'tester'}, {'id': 'annakarenina'})
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'genre'), 'romantic novel')
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'extra_not_found'), None)
assert_equal(h.get_pkg_dict_extra(pkg_dict, 'extra_not_found', 'default_value'), 'default_value')
model.repo.rebuild_db()
def setup(self):
model.repo.init_db()
CreateTestData.create()
self.package_name = u'formsapi'
self.package_name_alt = u'formsapialt'
self.package_name_alt2 = u'formsapialt2'
self.apikey_header_name = config.get('apikey_header_name',
'X-CKAN-API-Key')
self.user = self.get_user_by_name(u'tester')
if not self.user:
self.user = self.create_user(name=u'tester')
self.user = self.get_user_by_name(u'tester')
model.add_user_to_role(self.user, model.Role.ADMIN, model.System())
model.repo.commit_and_remove()
self.extra_environ = {self.apikey_header_name: str(self.user.apikey)}
self.create_package(name=self.package_name)
def test_get_pkg_dict_extra():
from ckan.lib.create_test_data import CreateTestData
from ckan import model
CreateTestData.create()
pkg_dict = helpers.call_action("package_show", id="annakarenina")
assert h.get_pkg_dict_extra(pkg_dict, "genre") == "romantic novel"
assert h.get_pkg_dict_extra(pkg_dict, "extra_not_found") is None
assert (h.get_pkg_dict_extra(pkg_dict, "extra_not_found",
"default_value") == "default_value")
model.repo.rebuild_db()
def test_overall(self):
CreateTestData.create()
query = search.query_for(model.Package)
assert query.run({"q": "annakarenina"})["count"] == 1
assert query.run({"q": "warandpeace"})["count"] == 1
assert query.run({"q": ""})["count"] == 2
assert query.run({"q": "Tolstoy"})["count"] == 1
assert query.run({"q": "title:Novel"})["count"] == 1
assert query.run({"q": "title:peace"})["count"] == 0
assert query.run({"q": "name:warandpeace"})["count"] == 1
assert query.run({"q": "groups:david"})["count"] == 2
assert query.run({"q": "groups:roger"})["count"] == 1
assert query.run({"q": "groups:lenny"})["count"] == 0
assert query.run({"q": 'tags:"russian"'})["count"] == 2
assert query.run({"q": 'tags:"Flexible \u30a1"'})["count"] == 2
assert query.run({"q": "Flexible \u30a1"})["count"] == 2
assert query.run({"q": "Flexible"})["count"] == 2
assert query.run({"q": "flexible"})["count"] == 2
def test_resource_no_id(self):
CreateTestData.create()
context = {"model": model, "session": model.Session}
new_resource = {
"mimetype": None,
u"alt_url": u"empty resource group id",
"hash": u"abc123",
"description": u'Full text. Needs escaping: " Umlaut: \xfc',
"format": u"plain text",
"url": u"http://test_new",
"cache_url": None,
"cache_last_updated": None,
"state": u"active",
"mimetype_inner": None,
"url_type": None,
"last_modified": None,
"position": 0,
"size": None,
"size_extra": u"123",
"resource_type": None,
"name": None,
"package_id": "", # Just so we can save
}
resource_dict_save(new_resource, context)
model.Session.commit()
model.Session.remove()
# Remove the package id
del new_resource["package_id"]
res = (
model.Session.query(model.Resource)
.filter_by(url=u"http://test_new")
.one()
)
res_dictized = self.remove_changable_columns(
resource_dictize(res, context), True
)
assert res_dictized == new_resource, res_dictized
def test_user_dictize_as_anonymous(self):
"""Anonymous should not be able to see other's sensitive data."""
CreateTestData.create()
context = {"model": model, "session": model.Session, "user": ""}
user = model.User.by_name("tester")
user_dict = user_dictize(user, context)
# Check some of the non-sensitive data
assert "name" in user_dict
assert "about" in user_dict
# Check sensitive data is not available
assert "apikey" not in user_dict
assert "reset_key" not in user_dict
assert "email" not in user_dict
# Passwords should never be available
assert "password" not in user_dict
def test_user_dictize_as_same_user(self):
"""User should be able to see their own sensitive data."""
CreateTestData.create()
context = {"model": model, "session": model.Session, "user": "******"}
user = model.User.by_name("tester")
user_dict = user_dictize(user, context)
# Check some of the non-sensitive data
assert "name" in user_dict
assert "about" in user_dict
# Check sensitive data is available
assert "apikey" in user_dict
assert "email" in user_dict
# Passwords and reset keys should never be available
assert "password" not in user_dict
assert "reset_key" not in user_dict
