public IAuthorizationState RequestAccessToken(string refreshToken)
{
{
WebServerClient consumer = new WebServerClient(ServerDescription, ClientID, ClientSecret)
{
AuthorizationTracker = new AuthorizationTracker(Scope)
};
IAuthorizationState grantedAccess = PrepareAuthorizationState(refreshToken);
if (grantedAccess != null)
{
try
{
consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(ClientSecret);
consumer.RefreshAuthorization(grantedAccess, null);
return grantedAccess;
}
catch (Exception ex)
{
log.Error("RefreshAuthorization() Exception:\r\n{0}\r\n", ex.ToString());
}
}
return null;
}
}
public async Task ResourceOwnerPasswordCredentialGrant(bool anonymousClient) {
var authHostMock = CreateAuthorizationServerMock();
if (anonymousClient) {
authHostMock.Setup(
m =>
m.IsAuthorizationValid(
It.Is<IAuthorizationDescription>(
d =>
d.ClientIdentifier == null && d.User == ResourceOwnerUsername &&
MessagingUtilities.AreEquivalent(d.Scope, TestScopes)))).Returns(true);
}
Handle(AuthorizationServerDescription.TokenEndpoint).By(async (req, ct) => {
var server = new AuthorizationServer(authHostMock.Object);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, ClientId, ClientSecret, this.HostFactories);
if (anonymousClient) {
client.ClientIdentifier = null;
}
var authState = await client.ExchangeUserCredentialForTokenAsync(ResourceOwnerUsername, ResourceOwnerPassword, TestScopes);
Assert.That(authState.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(authState.RefreshToken, Is.Not.Null.And.Not.Empty);
}
public static WebServerClient CreateClient()
{
AuthorizationServerDescription desc = GetAuthServerDescription();
var client = new WebServerClient(desc, clientIdentifier: "475779814525.apps.googleusercontent.com");
client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("plCPGSN2a218q7gHYmy0-BW1");
return client;
}
private WebServerClient CreateOAuth2Client() {
var serverDescription = new AuthorizationServerDescription {
TokenEndpoint = new Uri(tokenEndpointTextBox.Text)
};
var client = new WebServerClient(serverDescription, oauth2ClientIdTextBox.Text, oauth2ClientSecretTextBox.Text);
return (client);
}
public virtual IAuthorizationState ProcessUserAuthorization(
WebServerClient authClient, AuthorizationServerDescription authServer, IServiceBase authService)
{
return HostContext.Config.StripApplicationVirtualPath
? authClient.ProcessUserAuthorization(authService.Request.ToHttpRequestBase())
: authClient.ProcessUserAuthorization();
}
// GET: Account
public ActionResult Login(string returnUrl)
{
_webServerClient = OAuthConfiguration.InitializeWebServerClient();
var result = _webServerClient.ProcessUserAuthorization(Request);
if (result == null)
{
var userAuthorization = _webServerClient.PrepareRequestUserAuthorization();
//Clear returnUrl
userAuthorization.Send(HttpContext);
Response.End();
}
else
{
var username = OAuthConfiguration.GetMe(result.AccessToken);
var user = UserManager.FindByName(username);
if (user != null)
{
SignInManager.SignIn(user, false, false);
}
else
{
var newuser = new ApplicationUser { UserName = username, Email = username };
UserManager.Create(newuser);
SignInManager.SignIn(newuser, false, false);
}
return RedirectToLocal(returnUrl);
}
return View();
}
protected async void Button1_Click(object sender, EventArgs e)
{
var authServer = new AuthorizationServerDescription()
{
TokenEndpoint = new Uri("http://localhost:53022/OAuth/token "),
ProtocolVersion = ProtocolVersion.V20
};
WebServerClient Client= new WebServerClient(authServer, "idefav", "1");
var code =await Client.GetClientAccessTokenAsync(new string[] { "http://localhost:55045/IService1/DoWork" });
string token = code.AccessToken;
Service1Reference.Service1Client service1Client=new Service1Client();
var httpRequest = (HttpWebRequest)WebRequest.Create(service1Client.Endpoint.Address.Uri);
ClientBase.AuthorizeRequest(httpRequest,token);
var httpDetails = new HttpRequestMessageProperty();
httpDetails.Headers[HttpRequestHeader.Authorization] = httpRequest.Headers[HttpRequestHeader.Authorization];
using (var scope = new OperationContextScope(service1Client.InnerChannel))
{
if (OperationContext.Current.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))
{
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpDetails;
}
else
{
OperationContext.Current.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name, httpDetails);
}
Button1.Text= service1Client.DoWork();
}
}
protected virtual WebServerClient GetClient()
{
var client = new WebServerClient(description) {
ClientIdentifier = clientId,
ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(clientSecret),
};
return client;
}
private OAuth2Authenticator<WebServerClient> CreateAuthenticator()
{
// Register the authenticator.
var provider = new WebServerClient(GoogleAuthenticationServer.Description);
provider.ClientIdentifier = ClientCredentials.ClientID;
provider.ClientSecret = ClientCredentials.ClientSecret;
var authenticator =
new OAuth2Authenticator<WebServerClient>(provider, GetAuthorization) { NoCaching = true };
return authenticator;
}
private void InitializeWebServerClient()
{
var authorizationServerUri = new Uri("http://localhost:11625");
var authorizationServer = new AuthorizationServerDescription
{
AuthorizationEndpoint = new Uri(authorizationServerUri, "/OAuth/Authorize"),
TokenEndpoint = new Uri(authorizationServerUri, "/OAuth/Token")
};
_webServerClient = new WebServerClient(authorizationServer, "123456", "abcdef");
}
private WebServerClient GetClient(IOAuth2SignInSettings signInSettings)
{
AuthorizationServerDescription authorizationServerDescription = _endpointBuilder.Build(signInSettings);
var client = new WebServerClient(authorizationServerDescription)
{
ClientIdentifier = signInSettings.ClientId,
ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(signInSettings.ClientSecret)
};
return client;
}
private static void InitializeWebServerClient()
{
var authorizationServer = new AuthorizationServerDescription
{
AuthorizationEndpoint = new Uri(authorizationServerUri, "/oauth2/authorize"),
TokenEndpoint = new Uri(authorizationServerUri, "/api/oauth2/token"),
};
_webServerClient = new WebServerClient(authorizationServer, "resource_owner_test", "resource_owner_test");
}
private static void InitializeWebServerClient()
{
var authorizationServerUri = new Uri(Paths.AuthorizationServerBaseAddress);
var authorizationServer = new AuthorizationServerDescription
{
AuthorizationEndpoint = new Uri(authorizationServerUri, Paths.AuthorizePath),
TokenEndpoint = new Uri(authorizationServerUri, Paths.TokenPath)
};
_webServerClient = new WebServerClient(authorizationServer, Clients.Client1.Id, Clients.Client1.Secret);
}
public static WebServerClient CreateClient()
{
//pleasea contact hellopaisa for the credentials
var desc = GetAuthServerDescription();
//client ID provided
var client = new WebServerClient(desc, clientIdentifier: "ID");
//client secret/password provided
client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("SECRET");
return client;
}
/// <summary>
/// 使用DotNetOpenOAuth组件来模拟授权
/// </summary>
/// <returns></returns>
public ActionResult TestAuthorize()
{
var authServer = new AuthorizationServerDescription
{
AuthorizationEndpoint = new Uri("http://localhost:3335/OAuth/Authorize"),
TokenEndpoint = new Uri("http://localhost:3335/OAuth/Token")
};
var autoServerClient = new DotNetOpenAuth.OAuth2.WebServerClient(authServer, clientIdentifier: "fNm0EDIXbfuuDowUpAoq5GTEiywV8eg0TpiIVnV8", clientSecret: "clientSecret");
autoServerClient.RequestUserAuthorization(new string[] { "scope1" }, new Uri("http://localhost:3335/OAuth/GetAccessToken"));
return(new EmptyResult());
}
public ActionResult AuthorizationCodeGrant(AuthorizationCodeGrantViewModel viewModel)
{
if (ModelState.IsValid)
{
var client = new WebServerClient(_authServerDescription, viewModel.ClientId, viewModel.ClientSecret);
var request = client.PrepareRequestUserAuthorization(new[] { viewModel.Scope });
request.Send();
}
return View(viewModel);
}
protected OAuth2Authenticator(
AuthorizationServerDescription description,
Func<string, AuthResult.Data> selector,
string consumerKey,
string consumerSecret,
IEnumerable<string> scope)
{
_scope = scope;
_selector = selector;
_client = new WebServerClient(description)
{
ClientIdentifier = consumerKey,
ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(consumerSecret),
};
}
//private void Save(string date)
//{
// Configuration connectionConfiguration = WebConfigurationManager.OpenWebConfiguration("~");
// connectionConfiguration.AppSettings.Settings["access_token"].Value = date;
// connectionConfiguration.Save(ConfigurationSaveMode.Modified);
// ConfigurationManager.RefreshSection("appSettings");
//}
private static IAuthorizationState GetAccessToken()
{
var authorizationServer = new AuthorizationServerDescription
{
TokenEndpoint = new Uri(ConfigurationManager.AppSettings["Link_AccessToken"]),
ProtocolVersion = ProtocolVersion.V20
};
var client = new WebServerClient(authorizationServer, ConfigurationManager.AppSettings["LinkHost"]);
client.ClientIdentifier = ConfigurationManager.AppSettings["AppId"];
client.ClientSecret = ConfigurationManager.AppSettings["AppSecret"];
var state = client.GetClientAccessToken(null);
return state;
}
/// <summary>
/// Create an HTTP Handler that supports OAuth user authentication.
/// </summary>
/// <param name="authBaseUri">The base auth URI e.g. https://auth.alitudeangel.com</param>
/// <param name="clientId">Your client ID</param>
/// <param name="clientSecret">Your client secret</param>
/// <param name="scopes">Requested scopes</param>
/// <param name="existingState">(optional) An existing state object from a previous session. May be null.</param>
/// <param name="requireUserToken">true to aquire a user token, false to get a client only token.</param>
/// <param name="redirectUri">The redirect URI to use for user token auth. Must match the registered URI for your client ID.</param>
/// <param name="codeProvider">Implementation to use to get an authorization code URI from an auth login URI.</param>
/// <returns>
/// A <see cref="ClientHandlerInfo"/> object that contains the auth state and the handler. The auth state may be persisted and passed
/// back in on future runs of the application to save login state.
/// </returns>
public static ClientHandlerInfo Create(
string authBaseUri,
string clientId,
string clientSecret,
IEnumerable<string> scopes,
AuthorizationState existingState,
bool requireUserToken,
string redirectUri,
IAuthorizeCodeProvider codeProvider)
{
AuthorizationServerDescription serverDescription = GetServerDescription(authBaseUri);
ClientBase client;
IAuthorizationState state = existingState;
if (requireUserToken)
{
if (codeProvider == null || string.IsNullOrEmpty(redirectUri))
{
throw new ArgumentNullException(nameof(codeProvider),
$"{nameof(codeProvider)} or {nameof(redirectUri)} cannot be null if {nameof(requireUserToken)} is true.");
}
var userClient = new UserAgentClient(serverDescription, clientId, ClientCredentialApplicator.PostParameter(clientSecret));
if (state == null)
{
// Open browser here
var returnTo = new Uri(redirectUri);
Uri uri = userClient.RequestUserAuthorization(scopes, returnTo: returnTo);
Uri result = codeProvider.GetCodeUri(uri, returnTo).Result;
state = new AuthorizationState {Callback = returnTo};
state.Scope.AddRange(scopes);
state = userClient.ProcessUserAuthorization(result, state);
}
client = userClient;
}
else
{
client = new WebServerClient(serverDescription, clientId, ClientCredentialApplicator.PostParameter(clientSecret));
state = state ?? client.GetClientAccessToken(scopes);
}
return new ClientHandlerInfo(client.CreateAuthorizingHandler(state), state);
}
public ActionResult AuthorizationCodeGrant(string code, string state)
{
ViewBag.Message = "Modify this template to jump-start your ASP.NET MVC application.";
var model = new AuthorizationCodeGrantViewModel { ClientId = "demo-client-auth-code-identifier", ClientSecret = "demo-client-auth-code-secret-key", Scope = "user" };
if (!string.IsNullOrWhiteSpace(code) && !string.IsNullOrWhiteSpace(state))
{
var client = new WebServerClient(_authServerDescription, model.ClientId, model.ClientSecret);
this.ViewBag.AccessToken = client.ProcessUserAuthorization(this.Request);
}
this.ViewBag.AuthorizationCode = code;
this.ViewBag.AuthorizationState = state;
return this.View(model);
}
protected void Page_Load(object sender, EventArgs e)
{
var authorizationServer = new AuthorizationServerDescription
{
AuthorizationEndpoint = new Uri("http://localhost:18001/Katana.Sandbox.WebServer/Authorize"),
TokenEndpoint = new Uri("http://localhost:18001/Katana.Sandbox.WebServer/Token")
};
_webServerClient = new WebServerClient(authorizationServer, "123456", "abcdef");
if (string.IsNullOrEmpty(AccessToken.Text))
{
var authorizationState = _webServerClient.ProcessUserAuthorization(new HttpRequestWrapper(Request));
if (authorizationState != null)
{
AccessToken.Text = authorizationState.AccessToken;
Page.Form.Action = Request.Path;
}
}
}
public async Task DecodeRefreshToken() {
var refreshTokenSource = new TaskCompletionSource<string>();
Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
var request = await server.ReadAuthorizationRequestAsync(req, ct);
Assert.That(request, Is.Not.Null);
var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
return await server.Channel.PrepareResponseAsync(response);
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
var response = await server.HandleTokenRequestAsync(req, ct);
var authorization = server.DecodeRefreshToken(refreshTokenSource.Task.Result);
Assert.That(authorization, Is.Not.Null);
Assert.That(authorization.User, Is.EqualTo(ResourceOwnerUsername));
return response;
});
var client = new WebServerClient(AuthorizationServerDescription);
try {
var authState = new AuthorizationState(TestScopes) { Callback = ClientCallback, };
var authRedirectResponse = await client.PrepareRequestUserAuthorizationAsync(authState);
this.HostFactories.CookieContainer.SetCookies(authRedirectResponse, ClientCallback);
Uri authCompleteUri;
using (var httpClient = this.HostFactories.CreateHttpClient()) {
using (var response = await httpClient.GetAsync(authRedirectResponse.Headers.Location)) {
response.EnsureSuccessStatusCode();
authCompleteUri = response.Headers.Location;
}
}
var authCompleteRequest = new HttpRequestMessage(HttpMethod.Get, authCompleteUri);
this.HostFactories.CookieContainer.ApplyCookies(authCompleteRequest);
var result = await client.ProcessUserAuthorizationAsync(authCompleteRequest);
Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
refreshTokenSource.SetResult(result.RefreshToken);
} catch {
refreshTokenSource.TrySetCanceled();
}
}
public AuthorizationApi(string baseUrl, string consumerKey, string consumerSecret) {
this.BaseUrl = baseUrl;
ConsumerKey = consumerKey;
ConsumerSecret = consumerSecret;
var authEndpoint = new UriBuilder(BaseUrl);
authEndpoint.Path += "/oauth/auth";
var tokenEndpoint = new UriBuilder(BaseUrl);
tokenEndpoint.Path += "/oauth/token";
ServerDescription = new AuthorizationServerDescription {
AuthorizationEndpoint = authEndpoint.Uri,
TokenEndpoint = tokenEndpoint.Uri,
ProtocolVersion = ProtocolVersion.V20
};
oauthClient = new WebServerClient(ServerDescription, ConsumerKey, ConsumerSecret);
}
//Authentication Method
public void Authenticate()
{
var serverDescription = new AuthorizationServerDescription();
serverDescription.AuthorizationEndpoint = new Uri(AuthorizationEndpointUrl);
serverDescription.TokenEndpoint = new Uri(TokenEndpointUrl);
serverDescription.ProtocolVersion = ProtocolVersion.V20;
var client = new WebServerClient(serverDescription);
client.ClientIdentifier = ClientIdentifier;
client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(ClientSecret);
var token = client.GetClientAccessToken();
//var request = (HttpWebRequest)WebRequest.Create("http://localhost:8080/test/");
////System.Diagnostics.Process.Start("http://localhost:8080/test/");
//request.Method = "GET";
//client.AuthorizeRequest(request, token);
//var response = request.GetResponse();
//var postreqreader = new StreamReader(response.GetResponseStream());
//var json = postreqreader.ReadToEnd();
}
private IAuthorizationState GetAuthorization(WebServerClient client)
{
// If this user is already authenticated, then just return the auth state.
IAuthorizationState state = AuthState;
if (state != null)
{
return state;
}
// Check if an authorization request already is in progress.
state = client.ProcessUserAuthorization(new HttpRequestInfo(HttpContext.Current.Request));
if (state != null && (!string.IsNullOrEmpty(state.AccessToken) || !string.IsNullOrEmpty(state.RefreshToken)))
{
// Store and return the credentials.
HttpContext.Current.Session["AUTH_STATE"] = _state = state;
return state;
}
// Otherwise do a new authorization request.
string scope = TasksService.Scopes.TasksReadonly.GetStringValue();
OutgoingWebResponse response = client.PrepareRequestUserAuthorization(new[] { scope });
response.Send(); // Will throw a ThreadAbortException to prevent sending another response.
return null;
}
public async Task AuthorizationCodeGrant() {
Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
var request = await server.ReadAuthorizationRequestAsync(req, ct);
Assert.That(request, Is.Not.Null);
var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
return await server.Channel.PrepareResponseAsync(response, ct);
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, ClientId, ClientSecret, this.HostFactories);
var authState = new AuthorizationState(TestScopes) {
Callback = ClientCallback,
};
var authRequestRedirect = await client.PrepareRequestUserAuthorizationAsync(authState);
this.HostFactories.CookieContainer.SetCookies(authRequestRedirect, ClientCallback);
Uri authRequestResponse;
this.HostFactories.AllowAutoRedirects = false;
using (var httpClient = this.HostFactories.CreateHttpClient()) {
using (var httpResponse = await httpClient.GetAsync(authRequestRedirect.Headers.Location)) {
Assert.That(httpResponse.StatusCode, Is.EqualTo(HttpStatusCode.Redirect));
authRequestResponse = httpResponse.Headers.Location;
}
}
var authorizationResponse = new HttpRequestMessage(HttpMethod.Get, authRequestResponse);
this.HostFactories.CookieContainer.ApplyCookies(authorizationResponse);
var result = await client.ProcessUserAuthorizationAsync(authorizationResponse, CancellationToken.None);
Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
}
public async Task ResourceOwnerScopeOverride() {
var clientRequestedScopes = new[] { "scope1", "scope2" };
var serverOverriddenScopes = new[] { "scope1", "differentScope" };
var authServerMock = CreateAuthorizationServerMock();
authServerMock
.Setup(a => a.CheckAuthorizeResourceOwnerCredentialGrant(ResourceOwnerUsername, ResourceOwnerPassword, It.IsAny<IAccessTokenRequest>()))
.Returns<string, string, IAccessTokenRequest>((un, pw, req) => {
var response = new AutomatedUserAuthorizationCheckResponse(req, true, ResourceOwnerUsername);
response.ApprovedScope.Clear();
response.ApprovedScope.UnionWith(serverOverriddenScopes);
return response;
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, hostFactories: this.HostFactories);
var result = await client.ExchangeUserCredentialForTokenAsync(ResourceOwnerUsername, ResourceOwnerPassword, clientRequestedScopes);
Assert.That(result.Scope, Is.EquivalentTo(serverOverriddenScopes));
}
public async Task ClientCredentialScopeOverride() {
var clientRequestedScopes = new[] { "scope1", "scope2" };
var serverOverriddenScopes = new[] { "scope1", "differentScope" };
var authServerMock = CreateAuthorizationServerMock();
authServerMock
.Setup(a => a.CheckAuthorizeClientCredentialsGrant(It.IsAny<IAccessTokenRequest>()))
.Returns<IAccessTokenRequest>(req => {
var response = new AutomatedAuthorizationCheckResponse(req, true);
response.ApprovedScope.Clear();
response.ApprovedScope.UnionWith(serverOverriddenScopes);
return response;
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, ClientId, ClientSecret, this.HostFactories);
var result = await client.GetClientAccessTokenAsync(clientRequestedScopes);
Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(result.Scope, Is.EquivalentTo(serverOverriddenScopes));
}
public async Task CreateAccessTokenSeesAuthorizingUserClientCredentialGrant() {
var authServerMock = CreateAuthorizationServerMock();
authServerMock
.Setup(a => a.CheckAuthorizeClientCredentialsGrant(It.IsAny<IAccessTokenRequest>()))
.Returns<IAccessTokenRequest>(req => {
Assert.That(req.UserName, Is.Null);
return new AutomatedAuthorizationCheckResponse(req, true);
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, ClientId, ClientSecret, this.HostFactories);
var result = await client.GetClientAccessTokenAsync(TestScopes);
Assert.That(result.AccessToken, Is.Not.Null);
}
public async Task CreateAccessTokenSeesAuthorizingUserResourceOwnerGrant() {
var authServerMock = CreateAuthorizationServerMock();
authServerMock
.Setup(a => a.CheckAuthorizeResourceOwnerCredentialGrant(ResourceOwnerUsername, ResourceOwnerPassword, It.IsAny<IAccessTokenRequest>()))
.Returns<string, string, IAccessTokenRequest>((un, pw, req) => {
var response = new AutomatedUserAuthorizationCheckResponse(req, true, ResourceOwnerUsername);
Assert.That(req.UserName, Is.EqualTo(ResourceOwnerUsername));
return response;
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async (req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
return await server.HandleTokenRequestAsync(req, ct);
});
var client = new WebServerClient(AuthorizationServerDescription, hostFactories: this.HostFactories);
var result = await client.ExchangeUserCredentialForTokenAsync(ResourceOwnerUsername, ResourceOwnerPassword, TestScopes);
Assert.That(result.AccessToken, Is.Not.Null);
}
public void CreateAuthorizingHandlerAuthorization() {
var client = new WebServerClient(AuthorizationServerDescription);
string bearerToken = "mytoken";
var authorization = new Mock<IAuthorizationState>();
authorization.SetupGet(a => a.AccessToken).Returns(bearerToken);
var tcs = new TaskCompletionSource<HttpResponseMessage>();
var expectedResponse = new HttpResponseMessage();
var mockHandler = new DotNetOpenAuth.Test.Mocks.MockHttpMessageHandler((req, ct) => {
Assert.That(req.Headers.Authorization.Scheme, Is.EqualTo(Protocol.BearerHttpAuthorizationScheme));
Assert.That(req.Headers.Authorization.Parameter, Is.EqualTo(bearerToken));
tcs.SetResult(expectedResponse);
return tcs.Task;
});
var applicator = client.CreateAuthorizingHandler(authorization.Object, mockHandler);
var httpClient = new HttpClient(applicator);
var actualResponse = httpClient.GetAsync("http://localhost/someMessage").Result;
Assert.That(actualResponse, Is.SameAs(expectedResponse));
}
