Docs example doesn't build

[jbirnick]

I'm using the first example from the docs, but it doesn't build:

use oauth2::basic::BasicClient;
use oauth2::reqwest;
use oauth2::{
    AuthUrl, AuthorizationCode, ClientId, ClientSecret, CsrfToken, PkceCodeChallenge, RedirectUrl,
    Scope, TokenResponse, TokenUrl,
};
use url::Url;

fn main() {
    // Create an OAuth2 client by specifying the client ID, client secret, authorization URL and
    // token URL.
    let client = BasicClient::new(ClientId::new("client_id".to_string()))
        .set_client_secret(ClientSecret::new("client_secret".to_string()))
        .set_auth_uri(AuthUrl::new("http://authorize".to_string()).unwrap())
        .set_token_uri(TokenUrl::new("http://token".to_string()).unwrap())
        // Set the URL the user will be redirected to after the authorization process.
        .set_redirect_uri(RedirectUrl::new("http://redirect".to_string()).unwrap());

    // Generate a PKCE challenge.
    let (pkce_challenge, pkce_verifier) = PkceCodeChallenge::new_random_sha256();

    // Generate the full authorization URL.
    let (auth_url, csrf_token) = client
        .authorize_url(CsrfToken::new_random)
        // Set the desired scopes.
        .add_scope(Scope::new("read".to_string()))
        .add_scope(Scope::new("write".to_string()))
        // Set the PKCE code challenge.
        .set_pkce_challenge(pkce_challenge)
        .url();

    // This is the URL you should redirect the user to, in order to trigger the authorization
    // process.
    println!("Browse to: {}", auth_url);

    // Once the user has been redirected to the redirect URL, you'll have access to the
    // authorization code. For security reasons, your code should verify that the `state`
    // parameter returned by the server matches `csrf_token`.

    let http_client = reqwest::blocking::ClientBuilder::new()
        // Following redirects opens the client up to SSRF vulnerabilities.
        .redirect(reqwest::redirect::Policy::none())
        .build()
        .expect("Client should build");

    // Now you can trade it for an access token.
    let token_result = client
        .exchange_code(AuthorizationCode::new(
            "some authorization code".to_string(),
        ))
        // Set the PKCE code verifier.
        .set_pkce_verifier(pkce_verifier)
        .request(&http_client)?;
}

Here is the error:

error[E0277]: expected a `Fn(oauth2::http::Request<Vec<u8>>)` closure, found `oauth2::reqwest::blocking::Client`
  --> src/main.rs:53:10
   |
53 |         .request(&http_client)
   |          ^^^^^^^ expected an `Fn(oauth2::http::Request<Vec<u8>>)` closure, found `oauth2::reqwest::blocking::Client`
   |
   = help: the trait `Fn(oauth2::http::Request<Vec<u8>>)` is not implemented for `oauth2::reqwest::blocking::Client`
   = note: required for `oauth2::reqwest::blocking::Client` to implement `SyncHttpClient`

For more information about this error, try `rustc --explain E0277`.

[ramosbugs]

closing since I can't reproduce. cargo test --doc passes, including on that specific example:

   Doc-tests oauth2

running 13 tests
test src/lib.rs - (line 311) - compile ... ok
test src/lib.rs - (line 81) ... ignored
test src/lib.rs - (line 404) - compile ... ok
test src/lib.rs - (line 359) - compile ... ok
test src/lib.rs - (line 89) ... ignored
test src/lib.rs - (line 121) - compile ... ok
test src/lib.rs - (line 271) - compile ... ok
test src/lib.rs - (line 194) - compile ... ok

please make sure you're using the same version of this crate as the example you're copying from the documentation.

[jbirnick]

@ramosbugs I found the issue. You need to add the feature reqwest-blocking, which is not part of the default features, even though in the docs says you don't need any additional features:

oauth2-rs/src/lib.rs

Lines 117 to 119 in 096b286

	//! ## Example: Synchronous (blocking) API
	//!
	//! This example works with `oauth2`'s default feature flags, which include `reqwest`.

So maybe you could edit that and note that the feature reqwest-blocking is needed?

[YasushikoX]

I have the same issue, could the difference is in .toml file?

[YasushikoX]

As I thought, you need to include features = ["reqwest-blocking"] in the .toml, it should look something like this:

oauth2 = { version = "5.0.0", features = ["reqwest-blocking"] }

[iesahin]

It looks when "reqwest-blocking" feature is not listed, Client::set_token_uri doesn't set the respective type to EndpointSet and Client.exchange_code isn't available. I'm using for a Google OAuth2 workflow with the following type from examples:

pub type ConfiguredGoogleClient = Client<
    StandardErrorResponse<basic::BasicErrorResponseType>,
    StandardTokenResponse<EmptyExtraTokenFields, basic::BasicTokenType>,
    StandardTokenIntrospectionResponse<EmptyExtraTokenFields, basic::BasicTokenType>,
    StandardRevocableToken,
    StandardErrorResponse<oauth2::RevocationErrorResponseType>,
    EndpointSet,    // AuthUrl
    EndpointSet,    // TokenUrl
    EndpointNotSet, // IntrospectionUrl
    EndpointSet,    // RevocationUrl
    EndpointSet,    // RedirectUrl
>;

and the type of the client is not compatible with this, it's missing a EndpointSet for TokenUrl. I can open another issue and investigate more but it's probably about a missing feature flag or something.

Adding reqwest-blocking fixes this issue as well.

[jbirnick]

Sorry, but why are people still commenting here? I already mentioned the issue clearly in my second message:

You need to activate the feature flag reqwest-blocking.

That's it. Nothing more needed. The only reason the issue is still open is because this should be added to the docs.