Python ProjectFactory.add_unregistered_contributor方法代码示例

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
class TestUserGet(AdminTestCase):
    def setUp(self):
        super(TestUserGet, self).setUp()
        User.remove()
        self.user_1 = AuthUserFactory()
        self.auth = Auth(user=self.user_1)
        self.project = ProjectFactory(creator=self.user_1)
        self.project.add_unregistered_contributor(
            email='[email protected]',
            fullname='Weezy F. Baby',
            auth=self.auth
        )
        self.user_3 = AuthUserFactory()
        self.user_3.date_confirmed = None
        self.user_3.save()
        self.user_4 = AuthUserFactory()

    def test_get_all_user_count(self):
        time_now = datetime.utcnow()
        count = get_all_user_count(time_now)
        nt.assert_equal(count, 4)

    def test_get_unregistered_users(self):
        count = get_unregistered_users()
        nt.assert_equal(count, 1)

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
 def test_get_recently_added_contributors(self):
     project = ProjectFactory(creator=self.user)
     project.add_contributor(AuthUserFactory(), auth=self.auth)
     project.add_contributor(AuthUserFactory(), auth=self.auth)
     # has one unregistered contributor
     project.add_unregistered_contributor(fullname=fake.name(), email=fake.email(), auth=self.auth)
     project.save()
     url = self.project.api_url_for("get_recently_added_contributors")
     res = self.app.get(url, auth=self.user.auth)
     project.reload()
     recent = [c for c in self.user.recently_added if c.is_active]
     assert_equal(len(res.json["contributors"]), len(recent))

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
    def test_unregistered_users_names_are_project_specific(self):
        name1, name2, email = fake.name(), fake.name(), fake.email()
        project2 = ProjectFactory(creator=self.referrer)
        # different projects use different names for the same unreg contributor
        self.project.add_unregistered_contributor(email=email, fullname=name1, auth=Auth(self.referrer))
        self.project.save()
        project2.add_unregistered_contributor(email=email, fullname=name2, auth=Auth(self.referrer))
        project2.save()
        self.app.authenticate(*self.referrer.auth)
        # Each project displays a different name in the contributor list
        res = self.app.get(self.project.url)
        assert_in_html(name1, res)

        res2 = self.app.get(project2.url)
        assert_in_html(name2, res2)

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
class TestClaimingAsARegisteredUser(OsfTestCase):
    def setUp(self):
        super(TestClaimingAsARegisteredUser, self).setUp()
        self.referrer = AuthUserFactory()
        self.project = ProjectFactory(creator=self.referrer, is_public=True)
        name, email = fake.name(), fake.email()
        self.user = self.project.add_unregistered_contributor(fullname=name, email=email, auth=Auth(user=self.referrer))
        self.project.save()

    def test_claim_user_registered_with_correct_password(self):
        reg_user = AuthUserFactory()  # NOTE: AuthUserFactory sets password as 'password'
        url = self.user.get_claim_url(self.project._primary_key)
        # Follow to password re-enter page
        res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)

        # verify that the "Claim Account" form is returned
        assert_in("Claim Contributor", res.body)

        form = res.forms["claimContributorForm"]
        form["password"] = "password"
        res = form.submit(auth=reg_user.auth).follow(auth=reg_user.auth)

        self.project.reload()
        self.user.reload()
        # user is now a contributor to the project
        assert_in(reg_user._primary_key, self.project.contributors)

        # the unregistered user (self.user) is removed as a contributor, and their
        assert_not_in(self.user._primary_key, self.project.contributors)

        # unclaimed record for the project has been deleted
        assert_not_in(self.project._primary_key, self.user.unclaimed_records)

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
    def test_do_migration(self):
        user1 = UserFactory()

        fullname1 = 'Presentation Service'
        email1 = '[email protected]'
        project1 = ProjectFactory(creator=user1)
        user2 = project1.add_unregistered_contributor(
            fullname=fullname1, email=email1, auth=Auth(user=user1)
        )
        project1.save()

        user3 = UserFactory.build(username='[email protected]', fullname=fullname1)
        user3.save()
        project2 = ProjectFactory(creator=user1)
        project2.add_contributor(user3)
        project2.save()

        assert project1.is_contributor(user2) is True
        assert len(project1.contributors) is 2
        assert project2.is_contributor(user3) is True
        assert len(project2.contributors) is 2

        user_list = get_targets()
        do_migration(user_list)

        assert project2.is_contributor(user3) is False
        assert len(project2.contributors) is 1

        assert project1.is_contributor(user2) is False
        assert len(project1.contributors) is 1

        assert user2.is_disabled is True
        assert user3.is_disabled is True

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
    def test_migrate_project_contributed(self):
        user1 = UserFactory()

        fullname1 = 'hello world'
        email1 = '[email protected]'
        project1 = ProjectFactory(creator=user1)
        user2 = project1.add_unregistered_contributor(
            fullname=fullname1, email=email1, auth=Auth(user=user1)
        )
        project1.save()
        assert project1.is_contributor(user2) is True
        assert len(project1.contributors) is 2

        migrate_project_contributed(user2)
        assert project1.is_contributor(user2) is False
        assert len(project1.contributors) is 1

        user3 = UserFactory()
        project2 = ProjectFactory(creator=user1)
        project2.add_contributor(user3)
        project2.save()

        assert project2.is_contributor(user3) is True
        assert len(project2.contributors) is 2

        migrate_project_contributed(user3)
        assert project2.is_contributor(user3) is False
        assert len(project2.contributors) is 1

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
    def test_unregistered_contributor_detail_show_up_as_name_associated_with_project(self):
        project = ProjectFactory(creator=self.user, public=True)
        project.add_unregistered_contributor('Robert Jackson', '[email protected]', auth=Auth(self.user), save=True)
        unregistered_contributor = project.contributors[1]
        url = '/{}nodes/{}/contributors/{}/'.format(API_BASE, project._id, unregistered_contributor._id)
        res = self.app.get(url, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 200)
        assert_equal(res.json['data']['embeds']['users']['data']['attributes']['full_name'], 'Robert Jackson')
        assert_equal(res.json['data']['attributes'].get('unregistered_contributor'), 'Robert Jackson')

        project_two = ProjectFactory(creator=self.user, public=True)
        project_two.add_unregistered_contributor('Bob Jackson', '[email protected]', auth=Auth(self.user), save=True)
        url = '/{}nodes/{}/contributors/{}/'.format(API_BASE, project_two._id, unregistered_contributor._id)
        res = self.app.get(url, auth=self.user.auth, expect_errors=True)
        assert_equal(res.status_code, 200)

        assert_equal(res.json['data']['embeds']['users']['data']['attributes']['full_name'], 'Robert Jackson')
        assert_equal(res.json['data']['attributes'].get('unregistered_contributor'), 'Bob Jackson')

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
    def test_unregistered_contributor_added_has_contributor_info_in_params(self):
        project = ProjectFactory(creator=self.user)
        project.add_unregistered_contributor('Robert Jackson', '[email protected]', auth=Auth(self.user), save=True)
        unregistered_contributor = project.contributors[1]
        relevant_log = project.logs[-1]
        url = '/{}logs/{}/'.format(API_BASE, relevant_log._id)
        res = self.app.get(url, auth=self.user.auth)

        assert_equal(res.status_code, 200)

        params = res.json['data']['attributes']['params']
        params_node = params['params_node']
        contributors = params['contributors'][0]

        assert_equal(params_node['id'], project._id)
        assert_equal(params_node['title'], project.title)

        assert_equal(contributors['family_name'], 'Jackson')
        assert_equal(contributors['full_name'], 'Robert Jackson')
        assert_equal(contributors['given_name'], 'Robert')
        assert_equal(contributors['unregistered_name'], 'Robert Jackson')

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
class TestClaiming(OsfTestCase):

    def setUp(self):
        super(TestClaiming, self).setUp()
        self.referrer = AuthUserFactory()
        self.project = ProjectFactory(creator=self.referrer, is_public=True)

    def test_correct_name_shows_in_contributor_list(self):
        name1, email = fake.name(), fake.email()
        UnregUserFactory(fullname=name1, email=email)
        name2, email = fake.name(), fake.email()
        # Added with different name
        self.project.add_unregistered_contributor(fullname=name2,
            email=email, auth=Auth(self.referrer))
        self.project.save()

        res = self.app.get(self.project.url, auth=self.referrer.auth)
        # Correct name is shown
        assert_in_html(name2, res)
        assert_not_in(name1, res)

    def test_user_can_set_password_on_claim_page(self):
        name, email = fake.name(), fake.email()
        new_user = self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        claim_url = new_user.get_claim_url(self.project._primary_key)
        res = self.app.get(claim_url)
        self.project.reload()
        assert_in('Set Password', res)
        form = res.forms['setPasswordForm']
        #form['username'] = new_user.username #Removed as long as E-mail can't be updated.
        form['password'] = 'killerqueen'
        form['password2'] = 'killerqueen'
        res = form.submit().follow()
        new_user.reload()
        assert_true(new_user.check_password('killerqueen'))

    def test_sees_is_redirected_if_user_already_logged_in(self):
        name, email = fake.name(), fake.email()
        new_user = self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        existing = AuthUserFactory()
        claim_url = new_user.get_claim_url(self.project._primary_key)
        # a user is already logged in
        res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
        assert_equal(res.status_code, 302)

    def test_unregistered_users_names_are_project_specific(self):
        name1, name2, email = fake.name(), fake.name(), fake.email()
        project2 = ProjectFactory(creator=self.referrer)
        # different projects use different names for the same unreg contributor
        self.project.add_unregistered_contributor(
            email=email,
            fullname=name1,
            auth=Auth(self.referrer)
        )
        self.project.save()
        project2.add_unregistered_contributor(
            email=email,
            fullname=name2,
            auth=Auth(self.referrer)
        )
        project2.save()
        self.app.authenticate(*self.referrer.auth)
        # Each project displays a different name in the contributor list
        res = self.app.get(self.project.url)
        assert_in_html(name1, res)

        res2 = self.app.get(project2.url)
        assert_in_html(name2, res2)

    @unittest.skip("as long as E-mails cannot be changed")
    def test_cannot_set_email_to_a_user_that_already_exists(self):
        reg_user = UserFactory()
        name, email = fake.name(), fake.email()
        new_user = self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        # Goes to claim url and successfully claims account
        claim_url = new_user.get_claim_url(self.project._primary_key)
        res = self.app.get(claim_url)
        self.project.reload()
        assert_in('Set Password', res)
        form = res.forms['setPasswordForm']
        # Fills out an email that is the username of another user
        form['username'] = reg_user.username
        form['password'] = 'killerqueen'
        form['password2'] = 'killerqueen'
        res = form.submit().maybe_follow(expect_errors=True)
#.........这里部分代码省略.........

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]

#.........这里部分代码省略.........
            visible=True,
        )
        self.project.add_contributor(
            AuthUserFactory(),
            auth=self.auth,
            visible=False,
        )
        self.project.save()
        # Set limit to three contributors
        url = self.project.api_url_for('get_contributors', limit=3)
        res = self.app.get(url, auth=self.user.auth)
        # Should be three visible contributors on the project
        assert_equal(
            len(res.json['contributors']),
            3,
        )
        # There should be two 'more' contributors not shown
        assert_equal(
            (res.json['more']),
            2,
        )

    def test_get_contributors_from_parent(self):
        self.project.add_contributor(
            AuthUserFactory(),
            auth=self.auth,
            visible=True,
        )
        self.project.add_contributor(
            AuthUserFactory(),
            auth=self.auth,
            visible=False,
        )
        self.project.save()
        component = NodeFactory(parent=self.project, creator=self.user)
        url = component.api_url_for('get_contributors_from_parent')
        res = self.app.get(url, auth=self.user.auth)
        # Should be one contributor to the parent who is both visible and
        # not a contributor on the component
        assert_equal(
            len(res.json['contributors']),
            1,
        )

    def test_get_most_in_common_contributors(self):
        # project 1 (contrib 1, contrib 2, unreg_contrib 3)
        #  - component 1 (contrib 1)
        # project 2 - add should show contrib 1 first (2 links), contrib 2 second (1 link)
        contributor_1 = AuthUserFactory()
        contributor_2 = AuthUserFactory()
        self.project.add_contributor(contributor_1, auth=self.auth)
        self.project.add_contributor(contributor_2, auth=self.auth)
        # has one unregistered contributor
        self.project.add_unregistered_contributor(
            fullname=fake.name(),
            email=fake.email(),
            auth=self.auth,
        )
        self.project.save()
        component = NodeFactory(parent=self.project, creator=self.user)
        component.add_contributor(contributor_1, auth=self.auth)
        component.save()
        project_2 = ProjectFactory(creator=self.user)
        project_2.add_contributor(contributor_1, auth=self.auth)
        url = project_2.api_url_for('get_most_in_common_contributors')
        res = self.app.get(url, auth=self.user.auth)
        project_2.reload()
        res_contribs = res.json['contributors']
        assert_equal(len(res.json['contributors']), 2)
        assert_equal(contributor_1._id, res_contribs[0]['id'])
        assert_equal(res_contribs[0]['n_projects_in_common'], 2)
        assert_equal(contributor_2._id, res_contribs[1]['id'])
        assert_equal(res_contribs[1]['n_projects_in_common'], 1)

    def test_get_recently_added_contributors(self):
        project = ProjectFactory(creator=self.user)
        project.add_contributor(AuthUserFactory(), auth=self.auth)
        project.add_contributor(AuthUserFactory(), auth=self.auth)
        # has one unregistered contributor
        project.add_unregistered_contributor(
            fullname=fake.name(),
            email=fake.email(),
            auth=self.auth,
        )
        project.save()
        url = self.project.api_url_for('get_recently_added_contributors')
        res = self.app.get(url, auth=self.user.auth)
        project.reload()
        recent = [c for c in self.user.recently_added if c.is_active]
        assert_equal(len(res.json['contributors']), len(recent))

    def test_get_recently_added_contributors_with_limit(self):
        project = ProjectFactory(creator=self.user)
        for _ in range(5):
            project.add_contributor(AuthUserFactory(), auth=self.auth)
        project.save()
        url = self.project.api_url_for('get_recently_added_contributors', max=4)
        res = self.app.get(url, auth=self.user.auth)
        project.reload()
        assert_equal(len(res.json['contributors']), 4)

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
class TestClaimingAsARegisteredUser(OsfTestCase):

    def setUp(self):
        super(TestClaimingAsARegisteredUser, self).setUp()
        self.referrer = AuthUserFactory()
        self.project = ProjectFactory(creator=self.referrer, is_public=True)
        name, email = fake.name(), fake.email()
        self.user = self.project.add_unregistered_contributor(
            fullname=name,
            email=email,
            auth=Auth(user=self.referrer)
        )
        self.project.save()

    @mock.patch('website.project.views.contributor.session')
    def test_user_with_claim_url_registers_new_account(self, mock_session):
        # Assume that the unregistered user data is already stored in the session
        mock_session.data = {
            'unreg_user': {
                'uid': self.user._primary_key,
                'pid': self.project._primary_key,
                'token': self.user.get_unclaimed_record(
                    self.project._primary_key)['token']
            }
        }
        res2 = self.app.get('/account/')
        # Fills in Register form
        form = res2.forms['registerForm']
        form['register-fullname'] = 'tester'
        form['register-username'] = '[email protected]'
        form['register-username2'] = '[email protected]'
        form['register-password'] = 'testing'
        form['register-password2'] = 'testing'
        res3 = form.submit()

        assert_in('Registration successful.', res3.body)
        assert_in('Successfully claimed contributor', res3.body)

        u = User.find(Q('username', 'eq', '[email protected]'))[0]
        key = ApiKeyFactory()
        u.api_keys.append(key)
        u.save()
        u.auth = ('test', key._primary_key)
        self.app.get(u.get_confirmation_url('[email protected]')).follow(auth=u.auth)
        # Confirms their email address
        self.project.reload()
        self.user.reload()
        u.reload()
        assert_not_in(self.user._primary_key, self.project.contributors)
        assert_equal(2, len(self.project.contributors))
        # user is now a contributor to self.project
        assert_in(u._primary_key, self.project.contributors)

    @mock.patch('website.project.views.contributor.session')
    def test_user_can_log_in_with_a_different_account(self, mock_session):
        # Assume that the unregistered user data is already stored in the session
        mock_session.data = {
            'unreg_user': {
                'uid': self.user._primary_key,
                'pid': self.project._primary_key,
                'token': self.user.get_unclaimed_record(
                    self.project._primary_key)['token']
            }
        }
        right_user = AuthUserFactory.build(fullname="Right User")
        right_user.set_password('science')
        right_user.save()
        # User goes to the claim page, but a different user (lab_user) is logged in
        lab_user = AuthUserFactory(fullname="Lab Comp")

        url = self.user.get_claim_url(self.project._primary_key)
        res = self.app.get(url, auth=lab_user.auth).follow(auth=lab_user.auth)

        # verify that the "Claim Account" form is returned
        assert_in('Claim Contributor', res.body)

        # Clicks "I am not Lab Comp"
        # Taken to login/register page
        res2 = res.click(linkid='signOutLink', auth=lab_user.auth)
        # Fills in log in form
        form = res2.forms['signinForm']
        form['username'] = right_user.username
        form['password'] = 'science'
        # submits
        res3 = form.submit().follow()

        # Back at claim contributor page
        assert_in('Claim Contributor', res3)
        # Verifies their password
        form = res3.forms['claimContributorForm']
        form['password'] = 'science'
        form.submit()

        self.project.reload()
        right_user.reload()
        self.user.reload()
        # user is now a contributor to self.project
        assert_in(right_user._primary_key, self.project.contributors)

        # lab user is not a contributor
#.........这里部分代码省略.........

# 需要导入模块: from tests.factories import ProjectFactory [as 别名]
# 或者: from tests.factories.ProjectFactory import add_unregistered_contributor [as 别名]
class TestClaiming(OsfTestCase):

    def setUp(self):
        super(TestClaiming, self).setUp()
        self.referrer = AuthUserFactory()
        self.project = ProjectFactory(creator=self.referrer, is_public=True)

    def test_correct_name_shows_in_contributor_list(self):
        name1, email = fake.name(), fake.email()
        UnregUserFactory(fullname=name1, email=email)
        name2, email = fake.name(), fake.email()
        # Added with different name
        self.project.add_unregistered_contributor(fullname=name2,
            email=email, auth=Auth(self.referrer))
        self.project.save()

        res = self.app.get(self.project.url, auth=self.referrer.auth)
        # Correct name is shown
        assert_in(name2, res)
        assert_not_in(name1, res)

    def test_user_can_set_password_on_claim_page(self):
        name, email = fake.name(), fake.email()
        new_user = self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        claim_url = new_user.get_claim_url(self.project._primary_key)
        res = self.app.get(claim_url)
        self.project.reload()
        assert_in('Set Password', res)
        form = res.forms['setPasswordForm']
        form['username'] = new_user.username
        form['password'] = 'killerqueen'
        form['password2'] = 'killerqueen'
        res = form.submit().maybe_follow()
        new_user.reload()
        # at settings page
        assert_equal(res.request.path, '/settings/')
        assert_in('Welcome to the OSF', res)

    def test_sees_is_redirected_if_user_already_logged_in(self):
        name, email = fake.name(), fake.email()
        new_user = self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        existing = AuthUserFactory()
        claim_url = new_user.get_claim_url(self.project._primary_key)
        # a user is already logged in
        res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
        assert_equal(res.status_code, 302)

    def test_unregistered_users_names_are_project_specific(self):
        name1, name2, email = fake.name(), fake.name(), fake.email()
        project2 = ProjectFactory(creator=self.referrer)
        # different projects use different names for the same unreg contributor
        self.project.add_unregistered_contributor(
            email=email,
            fullname=name1,
            auth=Auth(self.referrer)
        )
        self.project.save()
        project2.add_unregistered_contributor(
            email=email,
            fullname=name2,
            auth=Auth(self.referrer)
        )
        project2.save()
        self.app.authenticate(*self.referrer.auth)
        # Each project displays a different name in the contributor list
        res = self.app.get(self.project.url)
        assert_in(name1, res)

        res2 = self.app.get(project2.url)
        assert_in(name2, res2)

    def test_unregistered_user_can_create_an_account(self):
        # User is added as an unregistered contributor to a project
        email, name = fake.email(), fake.name()
        self.project.add_unregistered_contributor(
            email=email,
            fullname=name,
            auth=Auth(self.referrer)
        )
        self.project.save()
        # Goes to registration page (instead of claiming their email)
        res = self.app.get('/account/').maybe_follow()
        form = res.forms['registerForm']
        form['register-fullname'] = name
        form['register-username'] = email
        form['register-username2'] = email
        form['register-password'] = 'example'
        form['register-password2'] = 'example'
        res = form.submit()
        # registered successfully
#.........这里部分代码省略.........