def manage_user(access_token, user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
name = username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = username_from_full_name(user.name)
user_repo.update(user)
return user
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
name = user_data['name'].encode('ascii', 'ignore').lower().replace(" ", "")
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=user_data['name'].encode('ascii', 'ignore')
.lower().replace(" ", ""),
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = user.name.encode('ascii', 'ignore').lower().replace(" ", "")
user_repo.update(user)
return user
def manage_user(access_token, user_data):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
facebook_token = dict(oauth_token=access_token)
if user is None:
info = dict(facebook_token=facebook_token)
name = username_from_full_name(user_data['name'])
user_exists = user_repo.get_by_name(name) is not None
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email_exists = (user_data.get('email') is not None and
user_repo.get_by(email_addr=user_data['email']) is not None)
if not user_exists and not email_exists:
if not user_data.get('email'):
user_data['email'] = name
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized() and user.email_addr != name:
newsletter.subscribe_user(user)
return user
else:
return None
else:
user.info['facebook_token'] = facebook_token
user_repo.save(user)
return user
def public_get_user_summary(name):
"""Sanitize user summary for public usage"""
private_user = get_user_summary(name)
public_user = None
if private_user is not None:
u = User()
public_user = u.to_public_json(data=private_user)
return public_user
def create_users(self):
root = User(
email_addr = self.root_addr,
name = self.root_name,
passwd_hash = self.root_password,
fullname = self.fullname,
api_key = self.root_api_key)
root.set_password(self.root_password)
user = User(
email_addr = self.email_addr,
name = self.name,
passwd_hash = self.password,
fullname = self.fullname,
api_key = self.api_key
)
user.set_password(self.password)
user2 = User(
email_addr = self.email_addr2,
name = self.name2,
passwd_hash = self.password + "2",
fullname = self.fullname2,
api_key=self.api_key_2)
user2.set_password(self.password)
return root, user, user2
def create_users(cls):
root = User(
email_addr = cls.root_addr,
name = cls.root_name,
passwd_hash = cls.root_password,
fullname = cls.fullname,
api_key = cls.root_api_key)
root.set_password(cls.root_password)
user = User(
email_addr = cls.email_addr,
name = cls.name,
passwd_hash = cls.password,
fullname = cls.fullname,
api_key = cls.api_key)
user.set_password(cls.password)
user2 = User(
email_addr = cls.email_addr2,
name = cls.name2,
passwd_hash = cls.password + "2",
fullname = cls.fullname2,
api_key=cls.api_key_2)
user2.set_password(cls.password)
return root, user, user2
def fixtures():
'''Create some fixtures!'''
with app.app_context():
user = User(
name=u'tester',
email_addr=u'*****@*****.**',
api_key='tester'
)
user.set_password(u'tester')
db.session.add(user)
db.session.commit()
def test_user_public_info_keys(self):
"""Test public info keys works."""
user = User(
email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
info=dict(avatar='image.png', container='foldr3', token='security'),
locale="en")
public_info_keys = ['avatar', 'container']
user.set_password("juandiso")
assert public_info_keys.sort() == user.public_info_keys().sort()
data = user.to_public_json()
err_msg = "There are some keys that should not be public"
assert data.get('info').keys().sort() == public_info_keys.sort(), err_msg
def manage_user(access_token, user_data):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
name = username_from_full_name(user_data['name'])
user_exists = user_repo.get_by_name(name) is not None
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email_exists = (user_data.get('email') is not None
and user_repo.get_by(email_addr=user_data['email'])
is not None)
if not user_exists and not email_exists:
if not user_data.get('email'):
user_data['email'] = name
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized() and user.email_addr != name:
newsletter.subscribe_user(user)
return user
else:
return None
else:
return user
def test_03_package_create(self, Mock):
"""Test CKAN package_create works"""
# It should return self.pkg_json_found with an empty Resources list
html_request = FakeRequest(json.dumps(self.pkg_json_found), 200,
{'content-type': 'application/json'})
Mock.return_value = html_request
with self.flask_app.test_request_context('/'):
# Resource that exists
project = Project(short_name='urbanpark', name='Urban Parks')
user = User(fullname='Daniel Lombrana Gonzalez')
out = self.ckan.package_create(project=project,
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_create(project=project,
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: the remote site failed! package_create failed" == type, type
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
user = db.session.query(User)\
.filter_by(facebook_user_id=user_data['id']).first()
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
user = db.session.query(User)\
.filter_by(name=user_data['username']).first()
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email = None
if user_data.get('email'):
email = db.session.query(User)\
.filter_by(email_addr=user_data['email']).first()
if user is None and email is None:
if not user_data.get('email'):
user_data['email'] = "None"
user = User(fullname=user_data['name'],
name=user_data['username'],
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
db.session.add(user)
db.session.commit()
return user
else:
return None
else:
return user
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.flask_app.test_request_context('/'):
# Resource that exists
project = Project(short_name='urbanpark', name='Urban Parks')
user = User(fullname='Daniel Lombrana Gonzalez')
self.ckan.package_create(project=project, 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: the remote site failed! resource_create failed" == type, type
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
user = user_repo.get_by(facebook_user_id=user_data['id'])
if user is None:
facebook_token = dict(oauth_token=access_token)
info = dict(facebook_token=facebook_token)
user = user_repo.get_by_name(user_data['username'])
# NOTE: Sometimes users at Facebook validate their accounts without
# registering an e-mail (see this http://stackoverflow.com/a/17809808)
email = None
if user_data.get('email'):
email = user_repo.get_by(email_addr=user_data['email'])
if user is None and email is None:
if not user_data.get('email'):
user_data['email'] = "None"
user = User(fullname=user_data['name'],
name=user_data['username'],
email_addr=user_data['email'],
facebook_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.app and user.email_addr != "None":
newsletter.subscribe_user(user)
return user
else:
return None
else:
return user
def test_task_run_errors(self):
"""Test TASK_RUN model errors."""
user = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
db.session.add(user)
db.session.commit()
user = db.session.query(User).first()
category = Category(name=u'cat', short_name=u'cat', description=u'cat')
project = Project(name='Application',
short_name='app',
description='desc',
owner_id=user.id,
category=category)
db.session.add(project)
db.session.commit()
task = Task(project_id=project.id)
db.session.add(task)
db.session.commit()
task_run = TaskRun(project_id=None, task_id=task.id)
db.session.add(task_run)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
task_run = TaskRun(project_id=project.id, task_id=None)
db.session.add(task_run)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# Wechat API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
info = dict(wechat_token=access_token)
user = user_repo.get_by(wechat_user_id=user_data['openid'])
if user is not None:
user.info['wechat_token'] = access_token
user_repo.save(user)
return user
user = user_repo.get_by_name(user_data['screen_name'])
if user is not None:
return None
user = User(fullname=user_data['screen_name'],
name=user_data['screen_name'],
email_addr=user_data['screen_name'],
wechat_user_id=user_data['openid'],
info=info)
user_repo.save(user)
return user
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
# Twitter API does not provide a way
# to get the e-mail so we will ask for it
# only the first time
user = user_repo.get_by(twitter_user_id=user_data['user_id'])
if user is not None:
return user
twitter_token = dict(oauth_token=access_token['oauth_token'],
oauth_token_secret=access_token['oauth_token_secret'])
info = dict(twitter_token=twitter_token)
user = user_repo.get_by_name(user_data['screen_name'])
if user is not None:
return None
user = User(fullname=user_data['screen_name'],
name=user_data['screen_name'],
email_addr=user_data['screen_name'],
twitter_user_id=user_data['user_id'],
info=info)
user_repo.save(user)
return user
def manage_user(user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(mykaarma_user_id=user_data['id'])
# user never signed on
if user is None:
user_by_email = user_repo.get_by(email_addr=user_data['email'])
if (user_by_email is None):
"""Generate 4 digit alphanumeric string with digits and lowercase characters"""
name = get_mykaarma_username_from_full_name(user_data['name'])
"""check if already a user present with the same name, if yes, generate another random string"""
user = user_repo.get_by_name(name)
while (user is not None):
name = get_mykaarma_username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
"""add user"""
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
mykaarma_user_id=user_data['id'])
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return add_through_email(user_by_email, user_data)
else:
return user
def test_user_errors(self):
"""Test USER model errors."""
user = 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 = User(name=username, fullname=username, email_addr=username)
info = {
'total': 150,
'long_description': 'hello world'}
app = App(
name=u'My New Project',
short_name=u'my-new-app',
description=u'description',
info=info)
category = Category(name=u'cat', short_name=u'cat', description=u'cat')
app.category = category
app.owner = user
task_info = {
'question': 'My random question',
'url': 'my url'}
task = Task(info=task_info)
task_run_info = {'answer': u'annakarenina'}
task_run = TaskRun(info=task_run_info)
task.app = app
task_run.task = task
task_run.app = app
task_run.user = user
db.session.add_all([user, app, task, task_run])
db.session.commit()
app_id = app.id
db.session.remove()
app = db.session.query(App).get(app_id)
assert app.name == u'My New Project', 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 = User.by_name(username)
assert user.apps[0].id == app_id, user
def test_get_users_page_returns_fields(self):
user = UserFactory.create()
TaskRunFactory.create(user=user)
fields = User.public_attributes()
users = cached_users.get_users_page(1)
for field in fields:
assert field in users[0].keys(), field
assert len(users[0].keys()) == len(fields)
def test_get_users_page_returns_fields(self):
user = UserFactory.create()
TaskRunFactory.create(user=user)
fields = User.public_attributes()
users = cached_users.get_users_page(1)
for field in fields:
assert field in list(users[0].keys()), field
assert len(list(users[0].keys())) == len(fields)
def test_app_errors(self):
"""Test project model errors."""
app = App(name='Project',
short_name='proj',
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 = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
db.session.add(user)
db.session.commit()
user = db.session.query(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 = "Project"
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 = "project"
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 _select_attributes(self, user_data):
if current_user.is_authenticated() and current_user.admin:
tmp = User().to_public_json(user_data)
tmp['id'] = user_data['id']
tmp['email_addr'] = user_data['email_addr']
return tmp
else:
privacy = self._is_user_private(user_data)
for attribute in user_data.keys():
self._remove_attribute_if_private(attribute, user_data, privacy)
return user_data
def test_is_authorized_calls_can_with_object_for_instances(
self, auth_factory):
authorizer = Mock()
auth_factory.return_value = authorizer
user = self.mock_authenticated
instance = User()
is_authorized(user, 'read', instance)
auth_factory.assert_called_with(instance.__class__.__name__.lower())
authorizer.can.assert_called_with(user, 'read', instance)
def test_get_leaderboard_returns_fields(self):
"""Test CACHE USERS get_leaderboard returns user fields"""
user = UserFactory.create()
TaskRunFactory.create(user=user)
fields = User.public_attributes()
leaderboard = cached_users.get_leaderboard(1)
for field in fields:
assert field in leaderboard[0].keys(), field
assert len(leaderboard[0].keys()) == len(fields)
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = db.session.query(User)\
.filter_by(google_user_id=user_data['id'])\
.first()
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
user = db.session.query(User)\
.filter_by(name=user_data['name'].encode('ascii', 'ignore')
.lower().replace(" ", ""))\
.first()
email = db.session.query(User)\
.filter_by(email_addr=user_data['email'])\
.first()
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=user_data['name'].encode(
'ascii', 'ignore').lower().replace(" ", ""),
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
db.session.add(user)
db.session.commit()
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = user.name.encode('ascii',
'ignore').lower().replace(" ", "")
db.session.add(user)
db.session.commit()
return user
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 = 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 = 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=' + self.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=' + self.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_get_leaderboard_returns_fields(self):
"""Test CACHE USERS get_leaderboard returns user fields"""
user = UserFactory.create()
TaskRunFactory.create(user=user)
fields = User.public_attributes()
update_leaderboard()
leaderboard = cached_users.get_leaderboard(1)
for field in fields:
assert field in leaderboard[0].keys(), field
assert len(leaderboard[0].keys()) == len(fields)
def test_user(self):
"""Test USER model."""
# First user
user = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
user2 = User(
email_addr="*****@*****.**",
name="johndoe2",
fullname="John Doe2",
locale="en",
)
db.session.add(user)
db.session.commit()
tmp = db.session.query(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(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 get_users_page(page, per_page=24):
"""Return users with a paginator."""
offset = (page - 1) * per_page
sql = text('''SELECT "user".id, "user".name,
"user".fullname, "user".email_addr,
"user".created, "user".info, COUNT(task_run.id) AS task_runs
FROM task_run, "user"
WHERE "user".id=task_run.user_id GROUP BY "user".id
ORDER BY "user".created DESC LIMIT :limit OFFSET :offset''')
results = session.execute(sql, dict(limit=per_page, offset=offset))
accounts = []
u = User()
for row in results:
user = dict(id=row.id, name=row.name, fullname=row.fullname,
email_addr=row.email_addr, created=row.created,
task_runs=row.task_runs, info=row.info,
registered_ago=pretty_date(row.created))
tmp = u.to_public_json(data=user)
accounts.append(tmp)
return accounts
def setUp(self):
super(TestBlogpostModel, self).setUp()
with self.flask_app.app_context():
user = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
category = Category(name=u'cat', short_name=u'cat', description=u'cat')
project = Project(name='Application', short_name='app', description='desc',
owner=user, category=category)
db.session.add(user)
db.session.add(project)
db.session.commit()
def get_users_page(page, per_page=24):
"""Return users with a paginator."""
offset = (page - 1) * per_page
sql = text('''SELECT "user".id, "user".name,
"user".fullname, "user".email_addr,
"user".created, "user".info, COUNT(task_run.id) AS task_runs
FROM task_run, "user"
WHERE "user".id=task_run.user_id GROUP BY "user".id
ORDER BY "user".created DESC LIMIT :limit OFFSET :offset''')
results = session.execute(sql, dict(limit=per_page, offset=offset))
accounts = []
u = User()
for row in results:
user = dict(id=row.id, name=row.name, fullname=row.fullname,
email_addr=row.email_addr, created=row.created,
task_runs=row.task_runs, info=row.info,
registered_ago=pretty_date(row.created))
tmp = u.to_public_json(data=user)
accounts.append(tmp)
return accounts
def test_to_public_json(self):
"""Test DomainObject to_public_json method works."""
user = User()
user.name = 'daniel'
user_dict = user.dictize()
json = user.to_public_json()
err_msg = "Wrong value"
assert json['name'] == user.name, err_msg
err_msg = "Missing fields"
assert json.keys().sort() == user.public_attributes().sort(), err_msg
json = user.to_public_json(data=user_dict)
err_msg = "Wrong value"
assert json['name'] == user.name, err_msg
err_msg = "Missing fields"
assert json.keys().sort() == user.public_attributes().sort(), err_msg
def setUp(self):
super(TestBlogpostModel, self).setUp()
with self.flask_app.app_context():
user = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
app = App(name='Application',
short_name='app',
description='desc',
owner=user)
db.session.add(user)
db.session.add(app)
db.session.commit()
def manage_user(access_token, user_data):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
google_token = dict(oauth_token=access_token)
print("user", user)
# user never signed on
if user is None:
info = dict(google_token=google_token)
name = username_from_full_name(user_data['name'])
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
print("email", email)
if ((user is None) and (email is None)):
if type(name) == bytes:
name = name.decode('utf-8')
user = User(fullname=user_data['name'],
name=name,
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.is_initialized():
newsletter.subscribe_user(user)
return user
else:
return None
else:
user.info['google_token'] = google_token
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == str or ' ' in user.name:
user.name = username_from_full_name(user.name).decode('utf-8')
user_repo.save(user)
return user
def test_blogpost_public_json(self):
"""Test BLOGPOST to public json works."""
self.configure_fixtures()
owner = User(
email_addr="*****@*****.**",
name="johndoe2",
fullname="John Doe2",
locale="en")
blogpost = Blogpost(title='title', body="body", project=self.project, owner=owner)
db.session.add(blogpost)
db.session.commit()
tmp = blogpost.to_public_json()
assert tmp.keys().sort() == Blogpost().public_attributes().sort()
assert Blogpost().public_info_keys() == []
def add_user_contributed_to_feed(conn, user_id, project_obj):
if user_id is not None:
sql_query = ('select fullname, name, info from "user" \
where id=%s') % user_id
results = conn.execute(sql_query)
for r in results:
tmp = dict(id=user_id,
name=r.name,
fullname=r.fullname,
info=r.info)
tmp = User().to_public_json(tmp)
tmp['project_name'] = project_obj['name']
tmp['project_short_name'] = project_obj['short_name']
tmp['action_updated'] = 'UserContribution'
update_feed(tmp)
def manage_user(access_token, user_data, next_url):
"""Manage the user after signin"""
# We have to store the oauth_token in the session to get the USER fields
user = user_repo.get_by(google_user_id=user_data['id'])
# user never signed on
if user is None:
google_token = dict(oauth_token=access_token)
info = dict(google_token=google_token)
name = user_data['name'].encode('ascii',
'ignore').lower().replace(" ", "")
user = user_repo.get_by_name(name)
email = user_repo.get_by(email_addr=user_data['email'])
if ((user is None) and (email is None)):
user = User(fullname=user_data['name'],
name=user_data['name'].encode(
'ascii', 'ignore').lower().replace(" ", ""),
email_addr=user_data['email'],
google_user_id=user_data['id'],
info=info)
user_repo.save(user)
if newsletter.app:
newsletter.subscribe_user(user)
return user
else:
return None
else:
# Update the name to fit with new paradigm to avoid UTF8 problems
if type(user.name) == unicode or ' ' in user.name:
user.name = user.name.encode('ascii',
'ignore').lower().replace(" ", "")
user_repo.update(user)
return user
def test_all(self):
"""Test MODEL works"""
username = u'test-user-1'
user = User(name=username, fullname=username, email_addr=username)
info = {'total': 150, 'long_description': 'hello world'}
project = Project(name=u'My New Project',
short_name=u'my-new-app',
description=u'description',
info=info)
category = Category(name=u'cat', short_name=u'cat', description=u'cat')
project.category = category
project.owner = user
task_info = {'question': 'My random question', 'url': 'my url'}
task = Task(info=task_info)
task_run_info = {'answer': u'annakarenina'}
task_run = TaskRun(info=task_run_info)
task.project = project
task_run.task = task
task_run.project = project
task_run.user = user
db.session.add_all([user, project, task, task_run])
db.session.commit()
project_id = project.id
db.session.remove()
project = db.session.query(Project).get(project_id)
assert project.name == u'My New Project', project
# year would start with 201...
assert project.created.startswith('201'), project.created
assert project.long_tasks == 0, project.long_tasks
assert project.hidden == 0, project.hidden
assert project.time_estimate == 0, project
assert project.time_limit == 0, project
assert project.calibration_frac == 0, project
assert project.bolt_course_id == 0
assert len(project.tasks) == 1, project
assert project.owner.name == username, project
out_task = project.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
def test_task_errors(self):
"""Test TASK model errors."""
user = User(email_addr="*****@*****.**",
name="johndoe",
fullname="John Doe",
locale="en")
db.session.add(user)
db.session.commit()
user = db.session.query(User).first()
app = App(name='Application',
short_name='app',
description='desc',
owner_id=user.id)
db.session.add(app)
db.session.commit()
task = Task(app_id=None)
db.session.add(task)
assert_raises(IntegrityError, db.session.commit)
db.session.rollback()
def test_blogpost_is_not_deleted_after_owner_deletion(self):
"""Test BLOGPOST a blogpost remains when its owner user is removed
from the system"""
self.configure_fixtures()
owner = User(
email_addr="*****@*****.**",
name="johndoe2",
fullname="John Doe2",
locale="en")
blogpost = Blogpost(title='title', body="body", project=self.project, owner=owner)
db.session.add(blogpost)
db.session.commit()
assert owner in db.session
assert blogpost in db.session
db.session.delete(owner)
db.session.commit()
assert owner not in db.session
assert blogpost in db.session
assert blogpost.owner == None, blogpost.owner
def _select_attributes(self, user_data):
if (current_user.is_authenticated() and
(current_user.admin or current_user.subadmin or
current_user.id == user_data['id'])):
tmp = User().to_public_json(user_data)
tmp['id'] = user_data['id']
tmp['email_addr'] = user_data['email_addr']
tmp['admin'] = user_data['admin']
tmp['subadmin'] = user_data['subadmin']
tmp['pro'] = user_data['pro']
tmp['enabled'] = user_data['enabled']
tmp['info'] = user_data['info']
metadata = user_data.get('info', {}).get('metadata')
if metadata:
tmp['info']['metadata'] = metadata
return tmp
else:
privacy = self._is_user_private(user_data)
for attribute in user_data.keys():
self._remove_attribute_if_private(attribute, user_data, privacy)
return user_data
def create_app_with_contributors(self, anonymous, registered, two_tasks=False, name='my_app'):
app = App(name=name,
short_name='%s_shortname' % name,
description=u'description')
app.owner = self.user
db.session.add(app)
task = Task(app=app)
db.session.add(task)
if two_tasks:
task2 = Task(app=app)
db.session.add(task2)
db.session.commit()
for i in range(anonymous):
task_run = TaskRun(app_id = app.id,
task_id = 1,
user_ip = '127.0.0.%s' % i)
db.session.add(task_run)
if two_tasks:
task_run2 = TaskRun(app_id = app.id,
task_id = 2,
user_ip = '127.0.0.%s' % i)
db.session.add(task_run2)
for i in range(registered):
user = User(email_addr = "*****@*****.**" % i,
name = "user%s" % i,
passwd_hash = "1234%s" % i,
fullname = "user_fullname%s" % i)
db.session.add(user)
task_run = TaskRun(app_id = app.id,
task_id = 1,
user = user)
db.session.add(task_run)
if two_tasks:
task_run2 = TaskRun(app_id = app.id,
task_id = 2,
user = user)
db.session.add(task_run2)
db.session.commit()
return app
def test_user_public_attributes(self):
"""Test public attributes works."""
user = User(
email_addr="*****@*****.**",
name="johndoe",
pro=1,
fullname="John Doe",
locale="en")
public_attributes = ['created', 'name', 'fullname', 'locale', 'info',
'task_runs', 'registered_ago', 'rank', 'score']
user.set_password("juandiso")
assert public_attributes.sort() == user.public_attributes().sort()
data = user.to_public_json()
err_msg = "There are some keys that should not be public"
assert data.keys().sort() == public_attributes.sort(), err_msg
all_attributes = user.dictize().keys()
s = set(public_attributes)
private_attributes = [x for x in all_attributes if x not in s]
for attr in private_attributes:
err_msg = "This attribute should be private %s" % attr
assert data.get(attr) is None, err_msg
def test_domain_object_error(self):
"""Test DomainObject errors work."""
user = User()
user.name = "John"
d = user.dictize()
user.undictize(d)
