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 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_info_public_keys(self): """Test DomainObject to_public_json method works.""" user = User() user.name = 'daniel' user.info = dict(container='3', avatar='img.png', token='secret') 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 err_msg = "There should be info keys" assert json['info']['container'] == '3', err_msg assert json['info']['avatar'] == 'img.png', err_msg err_msg = "This key should be missing" assert json['info'].get('token') is None, 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 err_msg = "There should be info keys" assert json['info']['container'] == '3', err_msg assert json['info']['avatar'] == 'img.png', err_msg err_msg = "This key should be missing" assert json['info'].get('token') is None, err_msg
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', 'n_answers', 'registered_ago', 'rank', 'score' ] user.set_password("juandiso") print(sorted(public_attributes)) print(sorted(user.public_attributes())) assert sorted(public_attributes) == sorted(user.public_attributes()) data = user.to_public_json() err_msg = "There are some keys that should not be public" assert sorted(list(data.keys())) == sorted(public_attributes), err_msg all_attributes = list(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 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 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(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_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='cat', short_name='cat', description='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 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 manage_user(access_token, user_data): """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 info = dict(twitter_token=access_token) user = user_repo.get_by(twitter_user_id=user_data['user_id']) if user is not None: user.info['twitter_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'], twitter_user_id=user_data['user_id'], 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 = db.session.query(User)\ .filter_by(twitter_user_id=user_data['user_id'])\ .first() 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 = db.session.query(User)\ .filter_by(name=user_data['screen_name'])\ .first() 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) db.session.add(user) db.session.commit() 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 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) # 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']) 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: user.info['google_token'] = google_token # 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.save(user) return user
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_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.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_update( project=project, user=user, url="http://something.com", resources=self.pkg_json_found['result']['resources']) 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( project=project, user=user, url="http://something.com", resources=self.pkg_json_found['result']['resources']) 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_update failed" == type, type
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 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_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_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_info_public_keys(self): """Test DomainObject to_public_json method works.""" user = User() user.name = 'daniel' user.info = dict(container='3', avatar='img.png', token='secret', badges=['awesome.png', 'incredible.png'], hidden=True) 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 list( json.keys()).sort() == user.public_attributes().sort(), err_msg err_msg = "There should be info keys" assert json['info']['container'] == '3', err_msg assert json['info']['avatar'] == 'img.png', err_msg err_msg = "This key should be missing" assert json['info'].get('token') is None, 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 list( json.keys()).sort() == user.public_attributes().sort(), err_msg err_msg = "There should be info keys" assert json['info']['container'] == '3', err_msg assert json['info']['avatar'] == 'img.png', err_msg err_msg = "This key should be missing" assert json['info'].get('token') is None, err_msg with patch.dict(self.flask_app.config, {'USER_INFO_PUBLIC_FIELDS': ['badges']}): json = user.to_public_json() assert list(json['info'].keys()).sort() == User().public_info_keys( ).sort(), err_msg assert 'badges' in list(json['info'].keys()) assert 'hidden' not in list(json['info'].keys())
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_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 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 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 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 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 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