def test_05_resource_create(self, Mock):
"""Test CKAN resource_create works"""
pkg_request = FakeRequest(json.dumps(self.pkg_json_found), 200,
{'content-type': 'application/json'})
rsrc_request = FakeRequest(
json.dumps(self.pkg_json_found['result']['resources'][0]), 200,
{'content-type': 'text/html'})
Mock.return_value = pkg_request
with self.app.test_request_context('/'):
# Resource that exists
app = model.App(short_name='urbanpark', name='Urban Parks')
user = model.User(fullname='Daniel Lombrana Gonzalez')
self.ckan.package_create(app=app,
user=user,
url="http://something.com")
Mock.return_value = rsrc_request
out = self.ckan.resource_create(name='task')
err_msg = "It should create the task resource"
assert out["id"] == self.task_resource_id, err_msg
Mock.return_value = self.server_error
try:
self.ckan.resource_create(name='something-goes-wrong')
except Exception as out:
type, msg, status_code = out.args
assert "Server Error" in msg, msg
assert 500 == status_code, status_code
assert "CKAN: resource_create failed" == type, type
def test_08_package_update(self, Mock):
"""Test CKAN package_update works"""
html_request = FakeRequest(json.dumps(self.pkg_json_found), 200,
{'content-type': 'application/json'})
Mock.return_value = html_request
with self.app.test_request_context('/'):
# Resource that exists
app = model.App(short_name='urbanpark', name='Urban Parks')
user = model.User(fullname='Daniel Lombrana Gonzalez')
out = self.ckan.package_update(app=app,
user=user,
url="http://something.com")
err_msg = "The package ID should be the same"
assert out['id'] == self.package_id, err_msg
# Check the exception
Mock.return_value = self.server_error
try:
self.ckan.package_update(app=app,
user=user,
url="http://something.com")
except Exception as out:
type, msg, status_code = out.args
assert "Server Error" in msg, msg
assert 500 == status_code, status_code
assert "CKAN: package_update failed" == type, type
def test_task_run_errors(self):
"""Test TASK_RUN model errors."""
user = model.User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
db.session.add(user)
db.session.commit()
user = db.session.query(model.User).first()
app = model.App(name='Application',
short_name='app',
description='desc',
owner_id=user.id)
db.session.add(app)
db.session.commit()
task = model.Task(app_id=app.id)
db.session.add(task)
db.session.commit()
task_run = model.TaskRun(app_id=None, task_id=task.id)
db.session.add(task_run)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
task_run = model.TaskRun(app_id=app.id, task_id=None)
db.session.add(task_run)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
def test_user_errors(self):
"""Test USER model errors."""
user = model.User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
# User.name should not be nullable
user.name = None
db.session.add(user)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
# User.fullname should not be nullable
user.name = "johndoe"
user.fullname = None
db.session.add(user)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
# User.email_addr should not be nullable
user.name = "johndoe"
user.fullname = "John Doe"
user.email_addr = None
db.session.add(user)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
def test_all(self):
"""Test MODEL works"""
username = u'test-user-1'
user = model.User(name=username)
info = {
'total': 150,
'long_description': 'hello world'
}
app = model.App(
name=u'My New App',
short_name=u'my-new-app',
info=info
)
app.owner = user
task_info = {
'question': 'My random question',
'url': 'my url'
}
task = model.Task(info=task_info)
task_run_info = {
'answer': u'annakarenina'
}
task_run = model.TaskRun(info=task_run_info)
task.app = app
task_run.task = task
task_run.user = user
db.session.add_all([user, app, task, task_run])
db.session.commit()
app_id = app.id
user_id = user.id
db.session.remove()
app = db.session.query(model.App).get(app_id)
assert app.name == u'My New App', app
# year would start with 201...
assert app.created.startswith('201'), app.created
assert app.long_tasks==0, app.long_tasks
assert app.hidden==0, app.hidden
assert app.time_estimate==0, app
assert app.time_limit==0, app
assert app.calibration_frac==0, app
assert app.bolt_course_id==0
assert len(app.tasks) == 1, app
assert app.owner.name == username, app
out_task = app.tasks[0]
assert out_task.info['question'] == task_info['question'], out_task
assert out_task.quorum==0, out_task
assert out_task.state=="ongoing", out_task
assert out_task.calibration==0, out_task
assert out_task.priority_0==0, out_task
assert len(out_task.task_runs) == 1, out_task
outrun = out_task.task_runs[0]
assert outrun.info['answer'] == task_run_info['answer'], outrun
assert outrun.user.name == username, outrun
user = model.User.by_name(username)
assert user.apps[0].id == app_id, user
def test_all(self):
"""Test MODEL works"""
username = u'test-user-1'
user = model.User(name=username)
info = {
'total': 150,
'long_description': 'hello world'
}
app = model.App(
name=u'My New App',
short_name=u'my-new-app',
info=info
)
app.owner = user
task_info = {
'question': 'My random question',
'url': 'my url'
}
task = model.Task(info=task_info)
task_run_info = {
'answer': u'annakarenina'
}
task_run = model.TaskRun(info=task_run_info)
task.app = app
task_run.task = task
task_run.user = user
model.Session.add_all([user, app, task, task_run])
model.Session.commit()
app_id = app.id
user_id = user.id
model.Session.remove()
app = model.Session.query(model.App).get(app_id)
assert app.name == u'My New App', app
# year would start with 201...
assert app.created.startswith('201'), app.created
assert len(app.tasks) == 1, app
assert app.owner.name == username, app
out_task = app.tasks[0]
assert out_task.info['question'] == task_info['question'], out_task
assert len(out_task.task_runs) == 1, out_task
outrun = out_task.task_runs[0]
assert outrun.info['answer'] == task_run_info['answer'], outrun
assert outrun.user.name == username, outrun
user = model.User.by_name(username)
assert user.apps[0].id == app_id, user
# TODO: better testing where we actually get a random task
task = model.new_task(app_id, user_id)
assert task is None, 'There should be no tasks for this user'
task = model.new_task(app_id)
assert task, task
def test_32_oauth_password(self):
"""Test WEB user sign in without password works"""
user = model.User(email_addr="*****@*****.**",
name="johndoe",
passwd_hash=None,
fullname="John Doe",
api_key="api-key")
db.session.add(user)
db.session.commit()
res = self.signin()
assert "Incorrect email/password" in res.data, res.data
def test_app_errors(self):
"""Test APP model errors."""
app = model.App(name='Application',
short_name='app',
description='desc',
owner_id=None)
# App.owner_id shoult not be nullable
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
# App.name shoult not be nullable
user = model.User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
db.session.add(user)
db.session.commit()
user = db.session.query(model.User).first()
app.owner_id = user.id
app.name = None
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
app.name = ''
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
# App.short_name shoult not be nullable
app.name = "Application"
app.short_name = None
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
app.short_name = ''
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
# App.description shoult not be nullable
db.session.add(app)
app.short_name = "app"
app.description = None
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
app.description = ''
db.session.add(app)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
def test_privacy_mode_user_queries(self):
"""Test API user queries for privacy mode with private fields in query
"""
# Add user with fullname 'Public user', privacy mode disabled
user_with_privacy_disabled = model.User(email_addr='*****@*****.**',
name='publicUser', fullname='User',
privacy_mode=False)
db.session.add(user_with_privacy_disabled)
# Add user with fullname 'Private user', privacy mode enabled
user_with_privacy_enabled = model.User(email_addr='*****@*****.**',
name='privateUser', fullname='User',
privacy_mode=True)
db.session.add(user_with_privacy_enabled)
db.session.commit()
# When querying with private fields
query = 'api/user?fullname=User'
# with no API-KEY, no user with privacy enabled should be returned,
# even if it matches the query
res = self.app.get(query)
data = json.loads(res.data)
assert len(data) == 1, data
public_user = data[0]
assert public_user['name'] == 'publicUser', public_user
# with a non-admin API-KEY, the result should be the same
res = self.app.get(query + '&api_key=' + Fixtures.api_key)
data = json.loads(res.data)
assert len(data) == 1, data
public_user = data[0]
assert public_user['name'] == 'publicUser', public_user
# with an admin API-KEY, all the matching results should be returned
res = self.app.get(query + '&api_key=' + Fixtures.root_api_key)
data = json.loads(res.data)
assert len(data) == 2, data
public_user = data[0]
assert public_user['name'] == 'publicUser', public_user
private_user = data[1]
assert private_user['name'] == 'privateUser', private_user
def test_user(self):
"""Test USER model."""
# First user
user = model.User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
user2 = model.User(
email_addr="*****@*****.**",
name="johndoe2",
fullname="John Doe2",
locale="en",
)
db.session.add(user)
db.session.commit()
tmp = db.session.query(model.User).get(1)
assert tmp.email_addr == user.email_addr, tmp
assert tmp.name == user.name, tmp
assert tmp.fullname == user.fullname, tmp
assert tmp.locale == user.locale, tmp
assert tmp.api_key is not None, tmp
assert tmp.created is not None, tmp
err_msg = "First user should be admin"
assert tmp.admin is True, err_msg
err_msg = "check_password method should return False"
assert tmp.check_password(password="******") is False, err_msg
db.session.add(user2)
db.session.commit()
tmp = db.session.query(model.User).get(2)
assert tmp.email_addr == user2.email_addr, tmp
assert tmp.name == user2.name, tmp
assert tmp.fullname == user2.fullname, tmp
assert tmp.locale == user2.locale, tmp
assert tmp.api_key is not None, tmp
assert tmp.created is not None, tmp
err_msg = "Second user should be not an admin"
assert tmp.admin is False, err_msg
def test_user(self):
"""Test MODEL User works"""
user = model.User(name=u'test-user', email_addr=u'*****@*****.**')
db.session.add(user)
db.session.commit()
db.session.remove()
user = model.User.by_name(u'test-user')
assert user, user
assert len(user.api_key) == 36, user
out = user.dictize()
assert out['name'] == u'test-user', out
def test_15_twitter_email_warning(self):
"""Test WEB Twitter email warning works"""
# This test assumes that the user allows Twitter to authenticate,
# returning a valid resp. The only difference is a user object
# without a password
# Register a user and sign out
user = model.User(name="tester",
passwd_hash="tester",
email_addr="tester")
user.set_password('tester')
db.session.add(user)
db.session.commit()
db.session.query(model.User).all()
# Sign in again and check the warning message
self.signin(username="******", password="******")
res = self.app.get('/', follow_redirects=True)
msg = "Please update your e-mail address in your profile page, " \
"right now it is empty!"
user = db.session.query(model.User).get(1)
assert msg in res.data, res.data
def test_privacy_mode_user_get(self):
"""Test API user queries for privacy mode"""
# Add user with fullname 'Public user', privacy mode disabled
user_with_privacy_disabled = model.User(email_addr='*****@*****.**',
name='publicUser', fullname='Public user',
privacy_mode=False)
db.session.add(user_with_privacy_disabled)
# Add user with fullname 'Private user', privacy mode enabled
user_with_privacy_enabled = model.User(email_addr='*****@*****.**',
name='privateUser', fullname='Private user',
privacy_mode=True)
db.session.add(user_with_privacy_enabled)
db.session.commit()
# With no API-KEY
# User with privacy disabled
res = self.app.get('/api/user/4')
data = json.loads(res.data)
user_with_privacy_disabled = data
# When checking a public field it should be returned
assert user_with_privacy_disabled['locale'] == 'en', data
# When checking a private field it should be returned too
assert user_with_privacy_disabled['fullname'] == 'Public user', data
# User with privacy enabled
res = self.app.get('/api/user/5')
data = json.loads(res.data)
user_with_privacy_enabled = data
# When checking a public field it should be returned
assert user_with_privacy_enabled['locale'] == 'en', data
# When checking a private field it should not be returned
assert 'fullname' not in user_with_privacy_enabled, data
# Users with privacy enabled and disabled, mixed together
res = self.app.get('/api/user')
data = json.loads(res.data)
user_with_privacy_disabled = data[3]
user_with_privacy_enabled = data[4]
assert user_with_privacy_disabled['locale'] == 'en', data
assert user_with_privacy_disabled['fullname'] == 'Public user', data
assert user_with_privacy_enabled['locale'] == 'en', data
assert 'fullname' not in user_with_privacy_enabled, data
# With a non-admin API-KEY
# User with privacy disabled
res = self.app.get('/api/user/4?api_key=' + Fixtures.api_key)
data = json.loads(res.data)
user_with_privacy_disabled = data
# When checking a public field it should be returned
assert user_with_privacy_disabled['locale'] == 'en', data
# When checking a private field it should be returned too
assert user_with_privacy_disabled['fullname'] == 'Public user', data
# User with privacy enabled
res = self.app.get('/api/user/5?api_key=' + Fixtures.api_key)
data = json.loads(res.data)
user_with_privacy_enabled = data
# When checking a public field it should be returned
assert user_with_privacy_enabled['locale'] == 'en', data
# When checking a private field it should not be returned
assert 'fullname' not in user_with_privacy_enabled, data
# Users with privacy enabled and disabled, mixed together
res = self.app.get('/api/user?api_key=' + Fixtures.api_key)
data = json.loads(res.data)
user_with_privacy_disabled = data[3]
user_with_privacy_enabled = data[4]
assert user_with_privacy_disabled['locale'] == 'en', data
assert user_with_privacy_disabled['fullname'] == 'Public user', data
assert user_with_privacy_enabled['locale'] == 'en', data
assert 'fullname' not in user_with_privacy_enabled, data
# Admin API-KEY should be able to retrieve every field in user
res = self.app.get('/api/user/4?api_key=' + Fixtures.root_api_key)
data = json.loads(res.data)
user_with_privacy_disabled = data
# When checking a public field it should be returned
assert user_with_privacy_disabled['locale'] == 'en', data
# When checking a private field it should be returned too
assert user_with_privacy_disabled['fullname'] == 'Public user', data
# User with privacy enabled
res = self.app.get('/api/user/5?api_key=' + Fixtures.root_api_key)
data = json.loads(res.data)
user_with_privacy_enabled = data
# When checking a public field it should be returned
assert user_with_privacy_enabled['locale'] == 'en', data
# When checking a private field it should be returned too
assert user_with_privacy_enabled['fullname'] == 'Private user', data
# Users with privacy enabled and disabled, mixed together
res = self.app.get('/api/user?api_key=' + Fixtures.root_api_key)
data = json.loads(res.data)
user_with_privacy_disabled = data[3]
user_with_privacy_enabled = data[4]
assert user_with_privacy_disabled['locale'] == 'en', data
assert user_with_privacy_disabled['fullname'] == 'Public user', data
assert user_with_privacy_enabled['locale'] == 'en', data
assert user_with_privacy_enabled['fullname'] == 'Private user', data
def test_domain_object_error(self):
"""Test DomainObject errors work."""
user = model.User()
user.name = "John"
d = user.dictize()
user.undictize(d)
