def serialize_urls(user_addon):
    return {
        'enable': api_url_for('twofactor_enable'),
        'disable': api_url_for('twofactor_disable'),
        'settings': api_url_for('twofactor_settings_put'),
        'otpauth': user_addon.otpauth_url if user_addon else '',
    }

    def test_revoke_badge_reason(self):
        badgeid = self.user_settings.badges[0]._id
        initnum = len(self.project.badgeassertion__awarded)
        assert_true(self.user_settings.can_award)
        url = api_url_for('award_badge', pid=self.project._id)
        ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
        self.project.reload()
        assert_equals(ret.status_int, 200)
        assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))

        assertion = self.project.badgeassertion__awarded[0]

        revoke = api_url_for('revoke_badge', pid=self.project._id)
        ret = self.app.post_json(revoke,
            {
                'id': assertion._id,
                'reason': 'Is a loser'
            }, auth=self.user.auth)
        self.project.reload()
        self.user_settings.reload()
        assertion.reload()

        assert_equals(ret.status_int, 200)
        assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
        assert_true(assertion._id in self.user_settings.revocation_list)
        assert_equals(len(self.user_settings.revocation_list), 1)
        assert_true(assertion.revoked)
        assert_equals(self.user_settings.revocation_list[assertion._id], 'Is a loser')

    def test_revoke_bad_aid(self):
        badgeid = self.user_settings.badges[0]._id
        initnum = len(self.project.badgeassertion__awarded)
        assert_true(self.user_settings.can_award)
        url = api_url_for('award_badge', pid=self.project._id)
        ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
        self.project.reload()
        assert_equals(ret.status_int, 200)
        assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))

        assertion = self.project.badgeassertion__awarded[0]

        revoke = api_url_for('revoke_badge', pid=self.project._id)

        ret = self.app.post_json(revoke,
            {
                'id': 'Im a bad id :D',
                'reason': ''
            }, auth=self.user.auth, expect_errors=True)
        self.project.reload()
        self.user_settings.reload()
        assertion.reload()

        assert_equals(ret.status_int, 400)
        assert_false(assertion.revoked)
        assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
        assert_false(assertion._id in self.user_settings.revocation_list)

    def test_change_subscription_to_adopt_parent_subscription_removes_user(self):
        payload = {
            'id': self.node._id,
            'event': 'comments',
            'notification_type': 'email_transactional'
        }
        url = api_url_for('configure_subscription')
        self.app.post_json(url, payload, auth=self.node.creator.auth)

        # check that subscription was created
        event_id = self.node._id + '_' + 'comments'
        s = NotificationSubscription.find_one(Q('_id', 'eq', event_id))

        # change subscription to adopt_parent
        new_payload = {
            'id': self.node._id,
            'event': 'comments',
            'notification_type': 'adopt_parent'
        }
        url = api_url_for('configure_subscription')
        self.app.post_json(url, new_payload, auth=self.node.creator.auth)
        s.reload()

        # assert that user is removed from the subscription entirely
        for n in constants.NOTIFICATION_TYPES:
            assert_false(self.node.creator in getattr(s, n))

    def test_create_new_subscription(self):
        payload = {
            'id': self.node._id,
            'event': 'comments',
            'notification_type': 'email_transactional'
        }
        url = api_url_for('configure_subscription')
        self.app.post_json(url, payload, auth=self.node.creator.auth)

        # check that subscription was created
        event_id = self.node._id + '_' + 'comments'
        s = NotificationSubscription.find_one(Q('_id', 'eq', event_id))

        # check that user was added to notification_type field
        assert_equal(payload['id'], s.owner._id)
        assert_equal(payload['event'], s.event_name)
        assert_in(self.node.creator, getattr(s, payload['notification_type']))

        # change subscription
        new_payload = {
            'id': self.node._id,
            'event': 'comments',
            'notification_type': 'email_digest'
        }
        url = api_url_for('configure_subscription')
        self.app.post_json(url, new_payload, auth=self.node.creator.auth)
        s.reload()
        assert_false(self.node.creator in getattr(s, payload['notification_type']))
        assert_in(self.node.creator, getattr(s, new_payload['notification_type']))

def box_user_config_get(user_addon, auth, **kwargs):
    """View for getting a JSON representation of the logged-in user's
    Box user settings.
    """
    urls = {
        'create': api_url_for('box_oauth_start_user'),
        'delete': api_url_for('box_oauth_delete_user')
    }
    valid_credentials = True

    if user_addon.has_auth:
        try:
            client = get_client_from_user_settings(user_addon)
            client.get_user_info()
        except BoxClientException:
            valid_credentials = False

    return {
        'result': {
            'urls': urls,
            'boxName': user_addon.username,
            'userHasAuth': user_addon.has_auth,
            'validCredentials': valid_credentials,
            'nNodesAuthorized': len(user_addon.nodes_authorized),
        },
    }

def dataverse_user_config_get(user_addon, auth, **kwargs):
    """View for getting a JSON representation of the logged-in user's
    Dataverse user settings.
    """
    try:
        connection = connect_from_settings_or_401(user_addon)
    except HTTPError as error:
        if error.code == 401:
            connection = None
        else:
            raise

    urls = {
        'create': api_url_for('dataverse_set_user_config'),
        'delete': api_url_for('dataverse_delete_user'),
        'apiToken': 'https://{0}/account/apitoken'.format(HOST),
    }
    return {
        'result': {
            'connected': connection is not None,
            'userHasAuth': user_addon.has_auth,
            'apiToken': user_addon.api_token,
            'urls': urls
        },
    }, http.OK

def dropbox_user_config_get(user_addon, auth, **kwargs):
    """View for getting a JSON representation of the logged-in user's
    Dropbox user settings.
    """
    urls = {
        'create': api_url_for('dropbox_oauth_start_user'),
        'delete': api_url_for('dropbox_oauth_delete_user')
    }
    info = user_addon.dropbox_info
    valid_credentials = True

    if user_addon.has_auth:
        try:
            client = get_client_from_user_settings(user_addon)
            client.account_info()
        except ErrorResponse as error:
            if error.status == 401:
                valid_credentials = False
            else:
                HTTPError(http.BAD_REQUEST)

    return {
        'result': {
            'userHasAuth': user_addon.has_auth,
            'validCredentials': valid_credentials,
            'dropboxName': info['display_name'] if info else None,
            'nNodesAuthorized': len(user_addon.nodes_authorized),
            'urls': urls
        },
    }, http.OK

    def test_revoke_badge_no_addon(self):
        badgeid = self.user_settings.badges[0]._id
        initnum = get_node_badges(self.project).count()
        assert_true(self.user_settings.can_award)
        url = api_url_for('award_badge', pid=self.project._id)
        ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
        self.project.reload()
        assert_equals(ret.status_int, 200)
        assert_equals(initnum + 1, get_node_badges(self.project).count())

        assertion = get_node_badges(self.project)[0]

        revoke = api_url_for('revoke_badge', pid=self.project._id)
        self.user.delete_addon('badges')
        self.user.save()
        self.user.reload()

        ret = self.app.post_json(revoke,
            {
                'id': assertion._id,
                'reason': ''
            }, auth=self.user.auth, expect_errors=True)
        self.project.reload()
        self.user_settings.reload()
        assertion.reload()

        assert_equals(ret.status_int, 400)
        assert_false(assertion.revoked)
        assert_true(get_node_badges(self.project)[0]._id, assertion._id)
        assert_false(assertion._id in self.user_settings.revocation_list)

    def test_revoke_didnt_award(self):
        badgeid = self.user_settings.badges[0]._id
        initnum = len(self.project.badgeassertion__awarded)
        assert_true(self.user_settings.can_award)
        url = api_url_for('award_badge', pid=self.project._id)
        ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
        self.project.reload()
        assert_equals(ret.status_int, 200)
        assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))

        assertion = self.project.badgeassertion__awarded[0]

        revoke = api_url_for('revoke_badge', pid=self.project._id)

        user2 = AuthUserFactory()
        user2.add_addon('badges', override=True)
        user2.save()
        user2.reload()

        ret = self.app.post_json(revoke,
            {
                'id': assertion._id,
                'reason': ''
            }, auth=user2.auth, expect_errors=True)
        self.project.reload()
        self.user_settings.reload()
        assertion.reload()

        assert_equals(ret.status_int, 400)
        assert_false(assertion.revoked)
        assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
        assert_false(assertion._id in self.user_settings.revocation_list)

 def test_dropbox_user_config_get_returns_correct_urls(self):
     url = api_url_for('dropbox_user_config_get')
     res = self.app.get(url, auth=self.user.auth)
     assert_equal(res.status_code, 200)
     # The JSONified URLs result
     urls = res.json['result']['urls']
     assert_equal(urls['delete'], api_url_for('dropbox_oauth_delete_user'))
     assert_equal(urls['create'], api_url_for('dropbox_oauth_start_user'))

 def test_drive_user_config_get_returns_correct_urls(self):
     self.user.add_addon("googledrive")
     url = api_url_for("googledrive_user_config_get", Auth(self.user))
     res = self.app.get(url)
     assert_equal(res.status_code, 200)
     result = res.json["result"]["urls"]
     assert_true(result["create"], api_url_for("googledrive_oauth_start_user"))
     assert_true(result["delete"], api_url_for("googledrive_oauth_delete_user"))

 def test_dropbox_user_config_get_returns_correct_urls(self, mock_account_info):
     mock_account_info.return_value = {'display_name': 'Mr. Drop Box'}
     url = api_url_for('dropbox_user_config_get')
     res = self.app.get(url, auth=self.user.auth)
     assert_equal(res.status_code, 200)
     # The JSONified URLs result
     urls = res.json['result']['urls']
     assert_equal(urls['delete'], api_url_for('dropbox_oauth_delete_user'))
     assert_equal(urls['create'], api_url_for('dropbox_oauth_start_user'))

    def test_dropbox_config_get(self):
        self.user_settings.save()

        url = api_url_for('dropbox_config_get', pid=self.project._primary_key)

        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.status_code, 200)
        result = res.json['result']
        assert_equal(result['ownerName'], self.user_settings.owner.fullname)

        assert_equal(result['urls']['config'],
            api_url_for('dropbox_config_put', pid=self.project._primary_key))

def dataverse_user_config_get(user_addon, **kwargs):
    """View for getting a JSON representation of the logged-in user's
    Dataverse user settings.
    """
    return {
        'result': {
            'userHasAuth': user_addon.has_auth,
            'urls': {
                'create': api_url_for('dataverse_add_user_account'),
                'accounts': api_url_for('dataverse_get_user_accounts'),
            },
            'hosts': DEFAULT_HOSTS,
        },
    }, http.OK

    def test_serialize_settings_helper_returns_correct_urls(self, mock_connection):
        mock_connection.return_value = create_mock_connection()

        # result =
        urls = self.serializer.serialized_urls

        assert_equal(urls['create'], api_url_for('dataverse_add_user_account'))
        assert_equal(urls['set'], self.project.api_url_for('dataverse_set_config'))
        assert_equal(urls['importAuth'], self.project.api_url_for('dataverse_add_user_auth'))
        assert_equal(urls['deauthorize'], self.project.api_url_for('dataverse_remove_user_auth'))
        assert_equal(urls['getDatasets'], self.project.api_url_for('dataverse_get_datasets'))
        assert_equal(urls['datasetPrefix'], 'http://dx.doi.org/')
        assert_equal(urls['dataversePrefix'], 'http://{0}/dataverse/'.format(self.host))
        assert_equal(urls['accounts'], api_url_for('dataverse_get_user_accounts'))

    def addon_serialized_urls(self):
        node = self.node_settings.owner
        external_account = self.node_settings.external_account
        host = external_account.oauth_key if external_account else ''

        return {
            'create': api_url_for('dataverse_add_user_account'),
            'set': node.api_url_for('dataverse_set_config'),
            'importAuth': node.api_url_for('dataverse_import_auth'),
            'deauthorize': node.api_url_for('dataverse_deauthorize_node'),
            'getDatasets': node.api_url_for('dataverse_get_datasets'),
            'datasetPrefix': 'https://doi.org/',
            'dataversePrefix': 'http://{0}/dataverse/'.format(host),
            'accounts': api_url_for('dataverse_account_list'),
        }

 def test_googledrive_oauth_start(self, mock_auth_client_start):
     url = api_url_for('googledrive_oauth_start_user', Auth(self.user))
     authorization_url = 'https://fake.domain/'
     state = 'secure state'
     mock_auth_client_start.return_value = (authorization_url, state)
     res = self.app.post(url)
     assert_true(res.json['url'], authorization_url)

 def test_googledrive_folders(self, mock_drive_client_folders):
     folderId = '12345'
     mock_drive_client_folders.return_value = mock_folders['items']
     url = api_url_for('googledrive_folders', pid=self.project._primary_key, folderId=folderId)
     res = self.app.get(url, auth=self.user.auth)
     assert_equal(res.status_code, 200)
     assert_equal(len(res.json), len(mock_folders['items']))

 def test_get_metaschemas(self):
     url = api_url_for('get_metaschemas')
     res = self.app.get(url).json
     assert_equal(
         len(res['meta_schemas']),
         MetaSchema.objects.filter(active=True, schema_version=LATEST_SCHEMA_VERSION).count()
     )