示例#1
0
 def test_handle_info_json(self):
     """Test handle info in JSON works."""
     TaskFactory.create(info={'foo': 'bar'})
     info = 'foo::bar'
     res = self.task_repo.filter_tasks_by(info=info)
     assert len(res) == 1
     assert res[0].info['foo'] == 'bar', res[0]
示例#2
0
    def test_serialization(self):
        project = ProjectFactory.create()
        self.db.session.commit()
        serializer = ProjectSerializer(strict=True)
        data = serializer.dump(project).data
        assert data['id'] == project.id
        assert data['name'] == project.name
        assert data['description'] == project.description
        assert data['last_task'] is None
        assert not data['tasks']
        assert data['client']['id'] == project.client.id

        task_1 = TaskFactory.create(project=project, status='open')
        task_2 = TaskFactory.create(project=project, status='closed')
        self.db.session.commit()

        # Last task
        data = serializer.dump(project).data
        assert data['last_task'] is not None
        assert data['last_task']['id'] == task_1.id
        assert data['last_task']['title'] == task_1.title
        assert 'time_entries' not in data['last_task']

        # Tasks (with filtering)
        data = ProjectSerializer(
            strict=True, task_status='open').dump(project).data
        assert len(data['tasks']) == 1
        assert data['tasks'][0]['id'] == task_1.id
        assert data['tasks'][0]['project_id'] == project.id
        data = ProjectSerializer(
            strict=True, task_status='closed').dump(project).data
        assert len(data['tasks']) == 1
        assert data['tasks'][0]['id'] == task_2.id
        assert data['tasks'][0]['project_id'] == project.id
示例#3
0
    def test_warn_project_excludes_completed_projects(self, clean_mock):
        """Test JOB email excludes completed projects."""
        from pybossa.core import mail
        with mail.record_messages() as outbox:
            date = '2010-10-22T11:02:00.000000'

            owner = UserFactory.create(consent=True, subscribed=True)
            project = ProjectFactory.create(updated=date, contacted=False,
                                            owner=owner)
            TaskFactory.create(created=date, project=project, state='completed')
            project_id = project.id
            project = project_repo.get(project_id)
            project.updated = date
            project_repo.update(project)

            project = ProjectFactory.create(updated=date, contacted=False,
                                            owner=owner)
            TaskFactory.create(created=date, project=project, state='ongoing')
            project_id = project.id
            project = project_repo.get(project_id)
            project.updated = date
            project_repo.update(project)

            warn_old_project_owners()
            assert len(outbox) == 1, outbox
            subject = 'Your PYBOSSA project: %s has been inactive' % project.name
            assert outbox[0].subject == subject
            err_msg = "project.contacted field should be True"
            assert project.contacted, err_msg
            err_msg = "project.published field should be False"
            assert project.published is False, err_msg
            err_msg = "cache of project should be cleaned"
            clean_mock.assert_called_with(project_id), err_msg
            err_msg = "The update date should be different"
            assert project.updated != date, err_msg
示例#4
0
    def test_admin_cannot_publish_if_project_has_no_presenter(self):
        """Test admins cannot publish a project that has no presenter"""
        owner = UserFactory.build_batch(2)[1]
        project = ProjectFactory.create(owner=owner, published=False, info={})
        TaskFactory.create(project=project)

        assert_raises(Forbidden, ensure_authorized_to, 'publish', project)
示例#5
0
    def test_n_total_tasks_site_returns_aggregated_number_of_required_tasks(self):
        TaskFactory.create(n_answers=2)
        TaskFactory.create(n_answers=2)

        tasks = stats.n_total_tasks_site()

        assert tasks == 4, tasks
示例#6
0
    def test_project_published(self):
        owner = UserFactory.create(email_addr='*****@*****.**', pro=True)
        owner.set_password('1234')
        user_repo.save(owner)
        project = ProjectFactory.create(owner=owner, published=False)
        self.signin(email='*****@*****.**', password='******')
        TaskFactory.create(project=project)
        short_name = project.short_name

        url = "/project/%s/publish" % short_name

        attribute = 'published'

        new_string = 'true'

        old_value = 'false'

        self.data[attribute] = new_string

        self.app.post(url, follow_redirects=True)

        logs = auditlog_repo.filter_by(project_short_name=short_name)
        assert len(logs) == 1, logs
        for log in logs:
            assert log.attribute == attribute, log.attribute
            assert log.old_value == old_value, (log.old_value, old_value)
            assert log.new_value == self.data[attribute], log.new_value
            assert log.caller == 'web', log.caller
            assert log.action == 'update', log.action
            assert log.user_name == owner.name, log.user_name
            assert log.user_id == owner.id, log.user_id
示例#7
0
    def test_orderby(self):
        """Test orderby."""
        project = ProjectFactory.create()
        task1 = TaskFactory.create(fav_user_ids=[1], project=project)
        task2 = TaskFactory.create(fav_user_ids=None, project=project)
        task3 = TaskFactory.create(fav_user_ids=[1, 2, 3], project=project)

        task = self.task_repo.filter_tasks_by(orderby='id', desc=True,
                                              project_id=project.id, limit=1)[0]
        assert task == task3, (task, task3)

        task = self.task_repo.filter_tasks_by(orderby='id', desc=False,
                                              project_id=project.id, limit=1)[0]
        assert task == task1, (task, task1)


        task = self.task_repo.filter_tasks_by(orderby='created', desc=True,
                                              project_id=project.id)[0]
        assert task == task3, (task.id, task3.id)

        task = self.task_repo.filter_tasks_by(orderby='created', desc=False,
                                              project_id=project.id)[0]
        assert task == task1, (task.created, task1.created)

        task = self.task_repo.filter_tasks_by(orderby='fav_user_ids', desc=True,
                                              project_id=project.id)[0][0]
        assert task == task3, (task.id, task3.id)

        task = self.task_repo.filter_tasks_by(orderby='fav_user_ids', desc=False,
                                              project_id=project.id)[0][0]
        assert task == task2, (task.fav_user_ids, task2.fav_user_ids)
    def test_it_renders_template_when_get(self, fake_render):
        TaskFactory.create(project=self.project)
        resp = self.app.get('/project/%s/publish' % self.project.short_name)

        call_args = fake_render.call_args_list
        assert call_args[0][0][0] == 'projects/publish.html', call_args[0]
        assert call_args[0][1]['project'].id == self.project.id, call_args[0]
示例#9
0
    def test_get_task_by_returns_none_if_no_task(self):
        """Test get_task_by returns None if no task matches the query"""

        TaskFactory.create(state='done')

        task = self.task_repo.get_task_by(state='ongoing')

        assert task is None, task
示例#10
0
    def test_count_tasks_with_no_matches(self):
        """Test count_tasks_with returns 0 if no tasks match the query"""

        TaskFactory.create(state='done', n_answers=17)

        count = self.task_repo.count_tasks_with(state='ongoing')

        assert count == 0, count
示例#11
0
 def test_handle_info_json_multiple_keys(self):
     """Test handle info in JSON with multiple keys works."""
     TaskFactory.create(info={'foo': 'bar', 'bar': 'foo'})
     info = 'foo::bar|bar::foo'
     res = self.task_repo.filter_tasks_by(info=info)
     assert len(res) == 1
     assert res[0].info['foo'] == 'bar', res[0]
     assert res[0].info['bar'] == 'foo', res[0]
示例#12
0
    def test_anonymous_01_newtask(self):
        """ Test SCHED newtask returns a Task for the Anonymous User"""
        project = ProjectFactory.create()
        TaskFactory.create(project=project, info='hola')

        res = self.app.get('api/project/%s/newtask' %project.id)
        data = json.loads(res.data)
        assert data['info'] == 'hola', data
示例#13
0
 def test_query_favorites_anon(self):
     """Test API Favorites works for anon."""
     user = UserFactory.create()
     TaskFactory.create(fav_user_ids=[user.id])
     res = self.app.get(self.url)
     data = json.loads(res.data)
     assert res.status_code == 401
     assert data['status_code'] == 401
示例#14
0
    def test_admin_can_publish_if_project_has_tasks_and_presenter(self):
        """Test admins can publish a project that has tasks and a presenter"""
        owner = UserFactory.build_batch(2)[1]
        project = ProjectFactory.create(owner=owner, published=False)
        TaskFactory.create(project=project)

        assert project.owner.id != self.mock_admin.id, project.owner
        assert_not_raises(Exception, ensure_authorized_to, 'publish', project)
示例#15
0
    def test_it_changes_project_to_published_after_post(self):
        TaskFactory.create(project=self.project)
        resp = self.app.post('/project/%s/publish' % self.project.short_name,
                             follow_redirects=True)

        project = project_repo.get(self.project.id)
        assert resp.status_code == 200, resp.status_code
        assert project.published == True, project
示例#16
0
    def test_get_query_with_api_key_context(self):
        """ Test API GET query with an API-KEY requesting only APIKEY results."""
        users = UserFactory.create_batch(4)
        project_oc = ProjectFactory.create(owner=users[0], info={'total': 150})
        projects = ProjectFactory.create_batch(3, owner=users[1])
        task_oc = TaskFactory.create(project=project_oc, info={'url': 'my url'})
        taskrun_oc = TaskRunFactory.create(task=task_oc, user=users[0],
                                        info={'answer': 'annakarenina'})
        for p in projects:
            print p.owner_id
            task_tmp = TaskFactory.create(project=p)
            TaskRunFactory.create(task=task_tmp)

        # For project owner with associated data
        for endpoint in self.endpoints:
            url = '/api/' + endpoint + '?api_key=' + users[0].api_key
            res = self.app.get(url)
            data = json.loads(res.data)

            if endpoint == 'project':
                assert len(data) == 1, data
                project = data[0]
                assert project['owner_id'] == users[0].id, project['owner_id']
                assert project['info']['total'] == 150, data
                assert res.mimetype == 'application/json', res

            if endpoint == 'task':
                assert len(data) == 1, data
                task = data[0]
                assert task['project_id'] == project_oc.id, task
                assert task['info']['url'] == 'my url', data
                assert res.mimetype == 'application/json', res

            if endpoint == 'taskrun':
                assert len(data) == 1, data
                taskrun = data[0]
                assert taskrun['project_id'] == project_oc.id, taskrun
                assert taskrun['info']['answer'] == 'annakarenina', data
                assert res.mimetype == 'application/json', res

        # For authenticated with non-associated data
        for endpoint in self.endpoints:
            url = '/api/' + endpoint + '?api_key=' + users[3].api_key

            res = self.app.get(url)
            data = json.loads(res.data)

            if endpoint == 'project':
                assert len(data) == 0, data
                assert res.mimetype == 'application/json', res

            if endpoint == 'task':
                assert len(data) == 0, data
                assert res.mimetype == 'application/json', res

            if endpoint == 'taskrun':
                assert len(data) == 0, data
                assert res.mimetype == 'application/json', res
示例#17
0
    def test_filter_tasks_by_no_matches(self):
        """Test filter_tasks_by returns an empty list if no tasks match the query"""

        TaskFactory.create(state='done', n_answers=17)

        retrieved_tasks = self.task_repo.filter_tasks_by(state='ongoing')

        assert isinstance(retrieved_tasks, list)
        assert len(retrieved_tasks) == 0, retrieved_tasks
    def test_normal_auth_used_if_no_password_protected(self, fake_authorizer):
        """Test if a project is password protected, that is the only authorization
        required for it to be seen"""
        project = ProjectFactory.create()
        TaskFactory.create(project=project)

        self.app.get('/project/%s' % project.short_name, follow_redirects=True)

        assert fake_authorizer.called == True
示例#19
0
    def test_count_tasks_with_multiple_conditions(self):
        """Test count_tasks_with supports multiple-condition queries"""

        TaskFactory.create(state='done', n_answers=17)
        task = TaskFactory.create(state='done', n_answers=99)

        count = self.task_repo.count_tasks_with(state='done', n_answers=99)

        assert count == 1, count
示例#20
0
 def test_handle_info_json_multiple_keys_404_fulltextsearch(self):
     """Test handle info in JSON with full text
     search with multiple keys not found works."""
     TaskFactory.create(info={'foo': 'bar', 'bar': 'foo'})
     info = 'foo::bar|'
     res = self.task_repo.filter_tasks_by(info=info, fulltextsearch='1')
     assert len(res) == 1
     assert res[0].info['foo'] == 'bar', res[0]
     assert res[0].info['bar'] == 'foo', res[0]
示例#21
0
    def test_password_not_required_for_anonymous_users_to_see_project(self):
        """Test when an anonymous user wants to visit a non-password
        protected project is able to do it"""
        project = ProjectFactory.create()
        TaskFactory.create(project=project)

        for endpoint in self.endpoints_requiring_password:
            res = self.app.get('/project/%s%s' % (project.short_name, endpoint),
                               follow_redirects=True)
            assert 'Enter the password to contribute' not in res.data, endpoint
    def test_get_draft_not_returns_published_projects(self):
        """Test CACHE PROJECTS get_draft does not return projects with either tasks or a presenter (REVIEW DEFINITION OF A DRAFT PROJECT REQUIRED)"""

        project_no_presenter = ProjectFactory.create(info={})
        TaskFactory.create(project=project_no_presenter)
        project_no_task = ProjectFactory.create()

        drafts = cached_projects.get_draft()

        assert len(drafts) is 0, drafts
示例#23
0
    def test_handle_info_json_multiple_keys_and_fulltextsearch(self):
        """Test handle info in JSON with multiple keys and AND operator works."""
        text = "agent myself you bar"
        TaskFactory.create(info={'foo': 'bar', 'bar': text})

        info = 'foo::bar|bar::you&agent'
        res = self.task_repo.filter_tasks_by(info=info, fulltextsearch='1')
        assert len(res) == 1, len(res)
        assert res[0].info['foo'] == 'bar', res[0]
        assert res[0].info['bar'] == text, res[0]
    def test_password_protection_overrides_normal_auth(self, fake_authorizer):
        """Test if a project is password protected, that is the only authorization
        required for it to be seen"""
        project = ProjectFactory.create(published=False)
        TaskFactory.create(project=project)
        project.set_password('mysecret')
        project_repo.update(project)

        self.app.get('/project/%s' % project.short_name, follow_redirects=True)

        assert fake_authorizer.called == False
示例#25
0
    def test_n_available_tasks_some_tasks_answered_by_authenticated_user(self):
        """Test n_available_tasks returns 1 for authenticated user if he has
        submitted taskruns for one of the tasks but there is still another task"""
        project = ProjectFactory.create()
        answered_task = TaskFactory.create(project=project)
        available_task = TaskFactory.create(project=project)
        user = UserFactory.create()
        taskrun = TaskRunFactory.create(task=answered_task, user=user)

        n_available_tasks = helpers.n_available_tasks(project.id, user_id=user.id)
        assert n_available_tasks == 1, n_available_tasks
示例#26
0
    def test_n_available_some_all_tasks_answered_by_anonymous_user(self):
        """Test n_available_tasks returns 1 for anonymous user if he has
        submitted taskruns for one of the tasks but there is still another task"""
        project = ProjectFactory.create()
        answered_task = TaskFactory.create(project=project)
        available_task = TaskFactory.create(project=project)
        taskrun = AnonymousTaskRunFactory.create(task=answered_task)

        n_available_tasks = helpers.n_available_tasks(project.id, user_ip=taskrun.user_ip)

        assert n_available_tasks == 1, n_available_tasks
示例#27
0
    def test_handle_info_json_fulltextsearch(self):
        """Test handle info fulltextsearch in JSON works."""
        text = 'bar word agent something'
        TaskFactory.create(info={'foo': text})
        info = 'foo::agent'
        res = self.task_repo.filter_tasks_by(info=info, fulltextsearch='1')
        assert len(res) == 1
        assert res[0].info['foo'] == text, res[0]

        res = self.task_repo.filter_tasks_by(info=info)
        assert len(res) == 0, len(res)
示例#28
0
    def test_filter_tasks_by_multiple_conditions(self):
        """Test filter_tasks_by supports multiple-condition queries"""

        TaskFactory.create(state='done', n_answers=17)
        task = TaskFactory.create(state='done', n_answers=99)

        retrieved_tasks = self.task_repo.filter_tasks_by(state='done',
                                                         n_answers=99)

        assert len(retrieved_tasks) == 1, retrieved_tasks
        assert task in retrieved_tasks, retrieved_tasks
    def test_password_not_required_for_anonymous_contributors(self):
        """Test when an anonymous user wants to contribute to a non-password
        protected project is able to do it"""
        project = ProjectFactory.create()
        TaskFactory.create(project=project)

        res = self.app.get('/project/%s/newtask' % project.short_name, follow_redirects=True)
        assert 'Enter the password to contribute' not in res.data

        res = self.app.get('/project/%s/task/1' % project.short_name, follow_redirects=True)
        assert 'Enter the password to contribute' not in res.data
示例#30
0
    def test_hidden_projects_only_returns_hidden(self):
        """Test CACHE USERS hidden_projects does not return draft (even hidden)
        or another user's hidden projects"""
        user = UserFactory.create()
        another_user_hidden_project = ProjectFactory.create(hidden=1)
        TaskFactory.create(project=another_user_hidden_project)
        hidden_draft_project = ProjectFactory.create(owner=user, hidden=1, info={})

        hidden_projects = cached_users.hidden_projects(user.id)

        assert len(hidden_projects) == 0, hidden_projects
    def test_password_view_func_post(self, redirect):
        """Test when posting to /project/short_name/password and password is correct
        the user is redirected to where they came from"""
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project)
        project.set_password('mysecret')
        project_repo.update(project)
        redirect_url = '/project/%s/task/%s' % (project.short_name, task.id)
        url = '/project/%s/password?next=%s' % (project.short_name,
                                                redirect_url)

        res = self.app.post(url, data={'password': '******'})
        redirect.assert_called_with(redirect_url)
    def test_password_view_func_post_wrong_passwd(self):
        """Test when posting to /project/short_name/password and password is incorrect
        an error message is flashed"""
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project)
        project.set_password('mysecret')
        project_repo.update(project)
        url = '/project/%s/password?next=/project/%s/task/%s' % (
            project.short_name, project.short_name, task.id)

        res = self.app.post(url, data={'password': '******'})
        assert 'Sorry, incorrect password' in str(
            res.data), "No error message shown"
示例#33
0
    def test_taskrun_empty_info(self):
        with patch.dict(self.flask_app.config, self.patch_config):
            project = ProjectFactory.create()
            task = TaskFactory.create(project=project)
            self.app.get('/api/project/%s/newtask?api_key=%s' %
                         (project.id, project.owner.api_key))

            data = dict(project_id=project.id, task_id=task.id, info=None)
            datajson = json.dumps(data)
            url = '/api/taskrun?api_key=%s' % project.owner.api_key

            success = self.app.post(url, data=datajson)
            assert success.status_code == 200, success.data
示例#34
0
    def test_check_contributing_state_completed_user_not_contributed(self):
        """Test check_contributing_state returns 'completed' for a project with all
        tasks completed even if the user has not contributed to it"""
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project, n_answers=2)
        TaskRunFactory.create_batch(2, task=task)
        user = UserFactory.create()
        update_stats(project.id)
        contributing_state = helpers.check_contributing_state(project=project,
                                                              user_id=user.id)

        assert task.state == 'completed', task.state
        assert contributing_state == 'completed', contributing_state
示例#35
0
    def test_n_available_tasks_all_tasks_answered_by_authenticated_user(self):
        """Test n_available_tasks returns 0 for authenticated user if he has
        submitted taskruns for all the tasks"""
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project, n_answers=2)
        user = UserFactory.create()
        taskrun = TaskRunFactory.create(task=task, user=user)

        n_available_tasks = helpers.n_available_tasks(project.id,
                                                      user_id=user.id)

        assert task.state != 'completed', task.state
        assert n_available_tasks == 0, n_available_tasks
示例#36
0
    def test_project_owner_can_crud(self):
        """Test project owner can crud tasks"""
        user = UserFactory.create()
        owner = UserFactory.create()
        project = ProjectFactory.create(owner=owner)
        task = TaskFactory.create(project=project)

        assert self.mock_authenticated.id == owner.id
        assert_not_raises(Forbidden, ensure_authorized_to, 'create', task)
        assert_not_raises(Forbidden, ensure_authorized_to, 'read', task)
        assert_not_raises(Forbidden, ensure_authorized_to, 'read', Task)
        assert_not_raises(Forbidden, ensure_authorized_to, 'update', task)
        assert_not_raises(Forbidden, ensure_authorized_to, 'delete', task)
示例#37
0
    def test_published_projects_returns_fields(self):
        """Test CACHE USERS published_projects returns the info of the projects with
        the required fields"""
        user = UserFactory.create()
        published_project = ProjectFactory.create(owner=user)
        task = TaskFactory.create(project=published_project)
        fields = ('id', 'name', 'short_name', 'owner_id', 'description',
                  'overall_progress', 'n_tasks', 'n_volunteers', 'info')

        projects_published = cached_users.published_projects(user.id)

        for field in fields:
            assert field in projects_published[0].keys(), field
示例#38
0
    def test_browse_tasks_returns_required_attributes(self):
        """Test CACHE PROJECTS browse_tasks returns a list with objects
        with the required task attributes"""

        project = ProjectFactory.create()
        task = TaskFactory.create(project=project, info={})
        attributes = ('id', 'n_answers')

        count, cached_tasks = cached_projects.browse_tasks(project.id, {})
        cached_task = cached_tasks[0]

        for attr in attributes:
            assert cached_task.get(attr) == getattr(task, attr), attr
    def test_project_report_with_task_details(self):
        """Test project report works with project details"""
        admin = UserFactory.create(admin=True)
        admin.set_password('1234')
        user_repo.save(admin)

        owner = UserFactory.create(pro=False)
        project = ProjectFactory.create(owner=owner)
        task = TaskFactory.create(project=project)
        TaskRunFactory.create(task=task)
        url = '/project/%s/projectreport/export?type=project&format=csv' % project.short_name
        res = self.app_get_json(url, follow_redirects=True)
        assert res.status_code == 200, res.data
示例#40
0
    def test_counter_works_default(self):
        """Test event listener when adding a task adds a counter."""

        task = TaskFactory.create()

        counter = db.session.query(Counter).filter_by(
            project_id=task.project.id, task_id=task.id).all()

        assert len(counter) == 1, counter
        counter = counter[0]
        assert counter.n_task_runs == 0, counter
        assert counter.task_id == task.id, counter
        assert counter.project_id == task.project.id, counter
示例#41
0
    def test_check_contributing_state_completed(self):
        """Test check_contributing_state returns 'completed' for a project with all
        tasks completed and user that has contributed to it"""
        app = AppFactory.create()
        task = TaskFactory.create(app=app, n_answers=1)
        user = UserFactory.create()
        TaskRunFactory.create_batch(1, task=task, user=user)

        contributing_state = helpers.check_contributing_state(app_id=app.id,
                                                              user_id=user.id)

        assert task.state == 'completed', task.state
        assert contributing_state == 'completed', contributing_state
示例#42
0
    def test_taskrun_authenticated_post(self, guard, mock_can_post):
        """Test API TaskRun creation and auth for authenticated users"""
        guard.return_value = mock_contributions_guard(True)
        mock_can_post.return_value = True
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project)
        data = dict(project_id=project.id,
                    task_id=task.id,
                    info='my task result')

        # With wrong project_id
        data['project_id'] = 100000000000000000
        datajson = json.dumps(data)
        url = '/api/taskrun?api_key=%s' % project.owner.api_key
        tmp = self.app.post(url, data=datajson)
        err_msg = "This post should fail as the project_id is wrong"
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, (err, err_msg)
        assert err['status'] == 'failed', (err, err_msg)
        assert err['status_code'] == 403, (err, err_msg)
        assert err['exception_msg'] == 'Invalid project_id', (err, err_msg)
        assert err['exception_cls'] == 'Forbidden', (err, err_msg)
        assert err['target'] == 'taskrun', (err, err_msg)

        # With wrong task_id
        data['project_id'] = task.project_id
        data['task_id'] = 100000000000000000000
        datajson = json.dumps(data)
        tmp = self.app.post(url, data=datajson)
        err_msg = "This post should fail as the task_id is wrong"
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, (err, err_msg)
        assert err['status'] == 'failed', (err, err_msg)
        assert err['status_code'] == 403, (err, err_msg)
        assert err['exception_msg'] == 'Invalid task_id', (err, err_msg)
        assert err['exception_cls'] == 'Forbidden', (err, err_msg)
        assert err['target'] == 'taskrun', (err, err_msg)

        # Now with everything fine
        data = dict(project_id=task.project_id,
                    task_id=task.id,
                    user_id=project.owner.id,
                    info='my task result')
        datajson = json.dumps(data)
        tmp = self.app.post(url, data=datajson)
        r_taskrun = json.loads(tmp.data)
        assert tmp.status_code == 200, r_taskrun

        # If the user tries again it should be forbidden
        tmp = self.app.post(url, data=datajson)
        assert tmp.status_code == 403, tmp.data
    def test_taskrun_anonymous_post(self, guard, mock_request):
        """Test API TaskRun creation and auth for anonymous users"""
        guard.return_value = mock_contributions_guard(True)
        project = ProjectFactory.create()
        task = TaskFactory.create(project=project)
        data = dict(project_id=project.id,
                    task_id=task.id,
                    info='my task result')
        mock_request.data = json.dumps(data)

        # With wrong project_id
        mock_request.remote_addr = '127.0.0.0'
        data['project_id'] = 100000000000000000
        datajson = json.dumps(data)
        tmp = self.app.post('/api/taskrun', data=datajson)
        err_msg = "This post should fail as the project_id is wrong"
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, tmp.data
        assert err['status'] == 'failed', err_msg
        assert err['status_code'] == 403, err_msg
        assert err['exception_msg'] == 'Invalid project_id', err_msg
        assert err['exception_cls'] == 'Forbidden', err_msg
        assert err['target'] == 'taskrun', err_msg

        # With wrong task_id
        data['project_id'] = task.project_id
        data['task_id'] = 100000000000000000000
        datajson = json.dumps(data)
        tmp = self.app.post('/api/taskrun', data=datajson)
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, err_msg
        assert err['status'] == 'failed', err_msg
        assert err['status_code'] == 403, err_msg
        assert err['exception_msg'] == 'Invalid task_id', err_msg
        assert err['exception_cls'] == 'Forbidden', err_msg
        assert err['target'] == 'taskrun', err_msg

        # Now with everything fine
        data = dict(project_id=task.project_id,
                    task_id=task.id,
                    info='my task result')
        datajson = json.dumps(data)
        tmp = self.app.post('/api/taskrun', data=datajson)
        r_taskrun = json.loads(tmp.data)
        assert tmp.status_code == 200, r_taskrun

        # If the anonymous tries again it should be forbidden
        tmp = self.app.post('/api/taskrun', data=datajson)
        err_msg = ("Anonymous users should be only allowed to post \
                    one task_run per task")
        assert tmp.status_code == 403, err_msg
示例#44
0
    def test_orderby(self):
        """Test orderby."""
        project = ProjectFactory.create()
        task1 = TaskFactory.create(fav_user_ids=[1], project=project)
        task2 = TaskFactory.create(fav_user_ids=None, project=project)
        task3 = TaskFactory.create(fav_user_ids=[1, 2, 3], project=project)

        task = self.task_repo.filter_tasks_by(orderby='id',
                                              desc=True,
                                              project_id=project.id,
                                              limit=1)[0]
        assert task == task3, (task, task3)

        task = self.task_repo.filter_tasks_by(orderby='id',
                                              desc=False,
                                              project_id=project.id,
                                              limit=1)[0]
        assert task == task1, (task, task1)

        task = self.task_repo.filter_tasks_by(orderby='created',
                                              desc=True,
                                              project_id=project.id)[0]
        assert task == task3, (task.id, task3.id)

        task = self.task_repo.filter_tasks_by(orderby='created',
                                              desc=False,
                                              project_id=project.id)[0]
        assert task == task1, (task.created, task1.created)

        task = self.task_repo.filter_tasks_by(orderby='fav_user_ids',
                                              desc=True,
                                              project_id=project.id)[0][0]
        assert task == task3, (task.id, task3.id)

        task = self.task_repo.filter_tasks_by(orderby='fav_user_ids',
                                              desc=False,
                                              project_id=project.id)[0][0]
        assert task == task2, (task.fav_user_ids, task2.fav_user_ids)
示例#45
0
    def test_tasks_assigned_as_per_user_access_levels_l2(self):
        """ Test tasks assigned by locked scheduler are as per access levels set for user and project"""

        from pybossa import data_access
        from test_api import get_pwd_cookie

        owner = UserFactory.create(id=500)
        user_l1 = UserFactory.create(id=502, info=dict(data_access=["L1"]))
        user_l2 = UserFactory.create(id=503, info=dict(data_access=["L2"]))

        project1 = ProjectFactory.create(owner=owner, info=dict(data_access=["L1"]))
        project1.info['sched'] = Schedulers.locked
        project_repo.save(project1)

        project2 = ProjectFactory.create(owner=owner, info=dict(data_access=["L2"]))
        project2.info['sched'] = Schedulers.user_pref
        project_repo.save(project2)

        taskp11 = TaskFactory.create(project=project1, info=dict(question='q1'), n_answers=1)
        taskp12 = TaskFactory.create(project=project1, info=dict(question='q2'), n_answers=1)
        taskp21 = TaskFactory.create(project=project2, info=dict(question='q3'), n_answers=1)
        taskp22 = TaskFactory.create(project=project2, info=dict(question='q4'), n_answers=1)

        self.set_proj_passwd_cookie(project1, user_l1)
        with patch.dict(data_access.data_access_levels, self.patch_data_access_levels):
            res = self.app.get('api/project/{}/newtask?api_key={}'
                               .format(project1.id, user_l1.api_key))
            assert res.status_code == 200, res.status_code

            data = json.loads(res.data)
            assert data['id'] == taskp11.id, 'user_l1 should have obtained task {}'.format(taskp11.id)

            self.set_proj_passwd_cookie(project2, user_l2)
            res = self.app.get('api/project/{}/newtask?api_key={}'
                               .format(project2.id, user_l2.api_key))
            assert res.status_code == 200, res.status_code
            data = json.loads(res.data)
            assert data['id'] == taskp21.id, 'user_l2 should have obtained task {}'.format(taskp21.id)
示例#46
0
 def test_export_consesus_metadata(self):
     project = ProjectFactory.create()
     task = TaskFactory.create(project=project,
                               info={'test': 2},
                               n_answers=1)
     task_run = TaskRunFactory.create(task=task, info={'hello': u'你好'})
     with export_consensus(project, 'tsk', 'csv', True, None) as fp:
         zipfile = ZipFile(fp)
         filename = zipfile.namelist()[0]
         df = DataFrame.from_csv(StringIO(zipfile.read(filename)))
     row = df.to_dict(orient='records')[0]
     assert json.loads(row['task_run__info'])[task_run.user.name] == {
         'hello': u'你好'
     }
示例#47
0
 def test_task_delete_deletes_zip_files(self, uploader):
     """Test API task delete deletes also zip files with tasks and taskruns"""
     admin = UserFactory.create()
     project = ProjectFactory.create(owner=admin)
     task = TaskFactory.create(project=project)
     url = '/api/task/%s?api_key=%s' % (task.id, admin.api_key)
     res = self.app.delete(url)
     expected = [
         call('1_project1_task_json.zip', 'user_1'),
         call('1_project1_task_csv.zip', 'user_1'),
         call('1_project1_task_run_json.zip', 'user_1'),
         call('1_project1_task_run_csv.zip', 'user_1')
     ]
     assert uploader.delete_file.call_args_list == expected
    def test_projects_contributed_contributions(self):
        """Test CACHE USERS projects_contributed returns a list of projects that has
        contributed to"""
        user = UserFactory.create()
        project_contributed = ProjectFactory.create()
        task = TaskFactory.create(project=project_contributed)
        TaskRunFactory.create(task=task, user=user)
        another_project = ProjectFactory.create()

        projects_contributed = cached_users.projects_contributed(user.id)

        assert len(projects_contributed) == 1
        assert projects_contributed[0][
            'short_name'] == project_contributed.short_name, projects_contributed
    def test_task_put_with_reserved_fields_returns_error(self):
        user = UserFactory.create()
        project = ProjectFactory.create(owner=user)
        task = TaskFactory.create(project=project)
        url = '/api/task/%s?api_key=%s' % (task.id, user.api_key)
        data = {'created': 'today',
                'state': 'completed',
                'id': 222}

        res = self.app.put(url, data=json.dumps(data))

        assert res.status_code == 400, res.status_code
        error = json.loads(res.data)
        assert error['exception_msg'] == "Reserved keys in payload", error
示例#50
0
    def test_apps_contributed_contributions(self):
        """Test CACHE USERS apps_contributed returns a list of projects that has
        contributed to"""
        user = UserFactory.create()
        app_contributed = AppFactory.create()
        task = TaskFactory.create(app=app_contributed)
        TaskRunFactory.create(task=task, user=user)
        another_app = AppFactory.create()

        apps_contributed = cached_users.apps_contributed(user.id)

        assert len(apps_contributed) == 1
        assert apps_contributed[0][
            'short_name'] == app_contributed.short_name, apps_contributed
示例#51
0
    def test_get_locked_task(self):
        owner = UserFactory.create(id=500)
        project = ProjectFactory.create(owner=owner)
        project.info['sched'] = Schedulers.locked
        project_repo.save(project)

        task1 = TaskFactory.create(project=project, info='task 1', n_answers=2)
        task2 = TaskFactory.create(project=project, info='task 2', n_answers=2)

        t1 = get_locked_task(project.id, 11)
        t2 = get_locked_task(project.id, 1)
        assert t1[0].id == task1.id
        assert t2[0].id == task1.id
        t3 = get_locked_task(project.id, 2)
        t4 = get_locked_task(project.id, 3)
        assert t3[0].id == task2.id
        assert t4[0].id == task2.id

        t5 = get_locked_task(project.id, 11)
        assert t5[0].id == task1.id

        t6 = get_locked_task(project.id, 4)
        assert not t6
示例#52
0
    def test_taskrun_authenticated_post(self):
        """Test API TaskRun creation and auth for authenticated users"""
        app = AppFactory.create()
        task = TaskFactory.create(app=app)
        data = dict(app_id=app.id, task_id=task.id, info='my task result')

        # With wrong app_id
        data['app_id'] = 100000000000000000
        datajson = json.dumps(data)
        url = '/api/taskrun?api_key=%s' % app.owner.api_key
        tmp = self.app.post(url, data=datajson)
        err_msg = "This post should fail as the app_id is wrong"
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, err_msg
        assert err['status'] == 'failed', err_msg
        assert err['status_code'] == 403, err_msg
        assert err['exception_msg'] == 'Invalid app_id', err_msg
        assert err['exception_cls'] == 'Forbidden', err_msg
        assert err['target'] == 'taskrun', err_msg

        # With wrong task_id
        data['app_id'] = task.app_id
        data['task_id'] = 100000000000000000000
        datajson = json.dumps(data)
        tmp = self.app.post(url, data=datajson)
        err_msg = "This post should fail as the task_id is wrong"
        err = json.loads(tmp.data)
        assert tmp.status_code == 403, err_msg
        assert err['status'] == 'failed', err_msg
        assert err['status_code'] == 403, err_msg
        assert err['exception_msg'] == 'Invalid task_id', err_msg
        assert err['exception_cls'] == 'Forbidden', err_msg
        assert err['target'] == 'taskrun', err_msg

        # Now with everything fine
        data = dict(app_id=task.app_id,
                    task_id=task.id,
                    user_id=app.owner.id,
                    info='my task result')
        datajson = json.dumps(data)
        tmp = self.app.post(url, data=datajson)
        r_taskrun = json.loads(tmp.data)
        assert tmp.status_code == 200, r_taskrun

        # If the user tries again it should be forbidden
        tmp = self.app.post(url, data=datajson)
        err_msg = ("Authorized users should be only allowed to post \
                    one task_run per task")
        task_runs = self.app.get('/api/taskrun')
        assert tmp.status_code == 403, tmp.data
示例#53
0
    def test_password_view_func_post_wrong_passwd(self):
        """Test when posting to /app/short_name/password and password is incorrect
        an error message is flashed"""
        app = AppFactory.create()
        task = TaskFactory.create(app=app)
        app.set_password('mysecret')
        db.session.add(app)
        db.session.commit()
        user = UserFactory.create()
        url = '/app/%s/password?next=/app/%s/task/%s' % (
            app.short_name, app.short_name, task.id)

        res = self.app.post(url, data={'password': '******'})
        assert 'Sorry, incorrect password' in res.data, "No error message shown"
示例#54
0
    def test_get_valid_project_levels_for_task(self):
        from pybossa import data_access

        task = TaskFactory.create(info={})
        with patch.object(data_access, 'data_access_levels',
                          self.patch_data_access_levels):
            self.patch_data_access_levels[
                'valid_project_levels_for_task_level'] = {
                    'A': ['B']
                }
            assert data_access.get_valid_project_levels_for_task(task) == set()
            task.info['data_access'] = ['A']
            assert data_access.get_valid_project_levels_for_task(task) == set(
                ['B'])
示例#55
0
    def test_password_view_func_post(self, redirect):
        """Test when posting to /app/short_name/password and password is correct
        the user is redirected to where they came from"""
        app = AppFactory.create()
        task = TaskFactory.create(app=app)
        app.set_password('mysecret')
        db.session.add(app)
        db.session.commit()
        user = UserFactory.create()
        redirect_url = '/app/%s/task/%s' % (app.short_name, task.id)
        url = '/app/%s/password?next=%s' % (app.short_name, redirect_url)

        res = self.app.post(url, data={'password': '******'})
        redirect.assert_called_with(redirect_url)
示例#56
0
 def test_trigger_webhook_with_url(self):
     """Test WEBHOOK is triggered with url."""
     url = 'http://server.com'
     project = ProjectFactory.create(webhook=url,)
     task = TaskFactory.create(project=project, n_answers=1)
     TaskRunFactory.create(project=project, task=task)
     payload = dict(event='task_completed',
                    project_short_name=project.short_name,
                    project_id=project.id,
                    task_id=task.id,
                    fired_at=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
     assert queue.enqueue.called
     assert queue.called_with(webhook, url, payload)
     queue.reset_mock()
示例#57
0
    def test_projects_contributed_returns_fields(self):
        """Test CACHE USERS projects_contributed returns the info of the projects with
        the required fields"""
        user = UserFactory.create()
        project_contributed = ProjectFactory.create()
        task = TaskFactory.create(project=project_contributed)
        TaskRunFactory.create(task=task, user=user)
        fields = ('id', 'name', 'short_name', 'owner_id', 'description',
                  'overall_progress', 'n_tasks', 'n_volunteers', 'info')

        projects_contributed = cached_users.projects_contributed(user.id)

        for field in fields:
            assert field in list(projects_contributed[0].keys()), field
示例#58
0
    def test_newtask_default_orderby(self):
        """Test SCHED depth first works with orderby."""
        project = ProjectFactory.create(info=dict(sched="depth_first"))
        task1 = TaskFactory.create(project=project, fav_user_ids=None)
        task2 = TaskFactory.create(project=project, fav_user_ids=[1,2,3])
        api_key = project.owner.api_key

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'id', False, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task1.id, data

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'id', True, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task2.id, data

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'created', False, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task1.id, data

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'created', True, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task2.id, data

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'fav_user_ids', False, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task1.id, data

        url = "/api/project/%s/newtask?orderby=%s&desc=%s&api_key=%s" % (project.id, 'fav_user_ids', True, api_key)
        res = self.app.get(url)
        data = json.loads(res.data)
        assert data['id'] == task2.id, data
        assert data['fav_user_ids'] == task2.fav_user_ids, data
示例#59
0
    def test_n_results_site_returns_valid_results_with_info(self):
        project = ProjectFactory.create()
        task = TaskFactory.create(n_answers=1, project=project)
        TaskRunFactory.create(task=task, project=project)
        result = result_repo.get_by(project_id=project.id)
        result.info = dict(foo='bar')
        result_repo.update(result)
        n_results = stats.n_results_site()

        assert n_results == 1, n_results

        project = ProjectFactory.create()
        task = TaskFactory.create(n_answers=1, project=project)
        TaskRunFactory.create(task=task, project=project)
        result = result_repo.get_by(project_id=project.id)
        result.info = dict(foo='bar2')
        result_repo.update(result)
        n_results = stats.n_results_site()

        assert n_results == 2, n_results

        self.create_result(n_results=10)

        assert n_results == 2, n_results
 def test_stats_dates_with_period(self):
     """Test CACHE PROJECT STATS dates with period works."""
     pr = ProjectFactory.create()
     d = date.today() - timedelta(days=6)
     task = TaskFactory.create(project=pr, n_answers=1, created=d)
     TaskRunFactory.create(project=pr, task=task, created=d, finish_time=d)
     dd = date.today() - timedelta(days=16)
     AnonymousTaskRunFactory.create(project=pr, created=dd, finish_time=dd)
     dates, dates_anon, dates_auth = stats_dates(pr.id, '1 week')
     assert len(dates) == 7, len(dates)
     assert len(dates_anon) == 7, len(dates_anon)
     assert len(dates_auth) == 7, len(dates_auth)
     assert dates[d.strftime('%Y-%m-%d')] == 1
     assert dates_anon[d.strftime('%Y-%m-%d')] == 0
     assert dates_auth[d.strftime('%Y-%m-%d')] == 1