Ejemplo n.º 1
0
    def test_set_auth_wrong_user(self):
        external_account = ZoteroAccountFactory()
        self.user.external_accounts.append(external_account)
        self.user.save()

        with assert_raises(PermissionsError):
            self.node_settings.set_auth(external_account=external_account,
                                        user=UserFactory())
Ejemplo n.º 2
0
    def _prep_oauth_case(self):
        self.node = ProjectFactory()
        self.user = self.node.creator

        self.external_account = ZoteroAccountFactory()

        self.user.external_accounts.append(self.external_account)
        self.user.save()

        self.user_settings = self.user.get_or_add_addon('zotero')
Ejemplo n.º 3
0
    def test_clear_auth(self):
        self.node_settings.external_account = ZoteroAccountFactory()
        self.node_settings.zotero_list_id = 'something'
        self.node_settings.user_settings = self.user_settings
        self.node_settings.save()

        self.node_settings.clear_auth()

        assert_is_none(self.node_settings.external_account)
        assert_is_none(self.node_settings.zotero_list_id)
        assert_is_none(self.node_settings.user_settings)
Ejemplo n.º 4
0
    def test_has_auth_true(self):
        external_account = ZoteroAccountFactory()
        self.user.external_accounts.append(external_account)

        self.node_settings.set_auth(external_account, self.user)

        # zotero_list_id should have no effect
        self.node_settings.zotero_list_id = None
        assert_true(self.node_settings.has_auth)

        # zotero_list_id should have no effect
        self.node_settings.zotero_list_id = 'totally fake ID'
        assert_true(self.node_settings.has_auth)
Ejemplo n.º 5
0
    def test_verify_oauth_access_no_metadata(self):
        self._prep_oauth_case()

        self.user_settings.grant_oauth_access(
            node=self.node,
            external_account=self.external_account,
        )
        self.user_settings.save()

        assert_true(
            self.user_settings.verify_oauth_access(
                node=self.node, external_account=self.external_account))

        assert_false(
            self.user_settings.verify_oauth_access(
                node=self.node, external_account=ZoteroAccountFactory()))
Ejemplo n.º 6
0
    def test_has_auth_false(self):
        external_account = ZoteroAccountFactory()

        assert_false(self.node_settings.has_auth)

        # both external_account and user_settings must be set to have auth
        self.node_settings.external_account = external_account
        assert_false(self.node_settings.has_auth)

        self.node_settings.external_account = None
        self.node_settings.user_settings = self.user_settings
        assert_false(self.node_settings.has_auth)

        # set_auth must be called to have auth
        self.node_settings.external_account = external_account
        self.node_settings.user_settings = self.user_settings
        assert_false(self.node_settings.has_auth)
Ejemplo n.º 7
0
    def test_deauthorize(self):
        self.node_settings.external_account = ZoteroAccountFactory()
        self.node_settings.zotero_list_id = 'something'
        self.node_settings.user_settings = self.user_settings
        self.node_settings.save()

        assert_true(self.node_settings.zotero_list_id)
        self.node_settings.deauthorize(auth=Auth(self.user))
        self.node_settings.save()
        assert_is(self.node_settings.user_settings, None)
        assert_is(self.node_settings.zotero_list_id, None)

        last_log = self.node.logs[-1]
        assert_equal(last_log.action, 'zotero_node_deauthorized')
        params = last_log.params
        assert_in('node', params)
        assert_in('project', params)
Ejemplo n.º 8
0
 def setUp(self):
     super(ZoteroViewsTestCase, self).setUp()
     self.account = ZoteroAccountFactory()
     self.user = AuthUserFactory(external_accounts=[self.account])
     self.account.display_name = self.user.fullname
     self.account.save()
     self.user_addon = ZoteroUserSettingsFactory(owner=self.user, external_account=self.account)
     self.project = ProjectFactory(creator=self.user)
     self.node_addon = ZoteroNodeSettingsFactory(owner=self.project)
     self.node_addon.set_auth(external_account=self.account, user=self.user)
     #self.user_addon.grant_oauth_access(self.node_addon, self.account, metadata={'lists': 'list'})
     self.node = MockNode()
     self.node.addon = self.node_addon
     self.id_patcher = mock.patch('website.addons.zotero.model.Zotero.client_id')
     self.secret_patcher = mock.patch('website.addons.zotero.model.Zotero.client_secret')
     self.id_patcher.__get__ = mock.Mock(return_value='1234567890asdf')
     self.secret_patcher.__get__ = mock.Mock(return_value='1234567890asdf')
     self.id_patcher.start()
     self.secret_patcher.start()
Ejemplo n.º 9
0
    def test_set_auth(self):
        external_account = ZoteroAccountFactory()
        self.user.external_accounts.append(external_account)
        self.user.save()

        # this should be reset after the call
        self.node_settings.zotero_list_id = 'anything'

        self.node_settings.set_auth(external_account=external_account,
                                    user=self.user)

        # this instance is updated
        assert_equal(self.node_settings.external_account, external_account)
        assert_equal(self.node_settings.user_settings, self.user_settings)
        assert_is_none(self.node_settings.zotero_list_id)

        # user_settings was updated
        # TODO: The call to grant_oauth_access in set_auth should be mocked
        assert_true(
            self.user_settings.verify_oauth_access(
                node=self.node,
                external_account=external_account,
            ))
Ejemplo n.º 10
0
    def test_set_target_folder(self):
        folder_id = 'fake-folder-id'
        folder_name = 'fake-folder-name'

        external_account = ZoteroAccountFactory()
        self.user.external_accounts.append(external_account)
        self.user.save()

        self.node_settings.set_auth(external_account=external_account,
                                    user=self.user)

        assert_is_none(self.node_settings.zotero_list_id)

        self.node_settings.set_target_folder(
            folder_id,
            folder_name,
            auth=Auth(user=self.user),
        )

        # instance was updated
        assert_equal(
            self.node_settings.zotero_list_id,
            'fake-folder-id',
        )

        # user_settings was updated
        # TODO: the call to grant_oauth_access should be mocked
        assert_true(
            self.user_settings.verify_oauth_access(
                node=self.node,
                external_account=external_account,
                metadata={'folder': 'fake-folder-id'}))

        log = self.node.logs[-1]
        assert_equal(log.action, 'zotero_folder_selected')
        assert_equal(log.params['folder_id'], folder_id)
        assert_equal(log.params['folder_name'], folder_name)