public void ProcessAsync_when_valiationresult_client_null_exect_exception()
{
var validationResult = new DeviceAuthorizationRequestValidationResult(new ValidatedDeviceAuthorizationRequest());
Func <Task> act = () => generator.ProcessAsync(validationResult, TestBaseUrl);
act.Should().Throw <ArgumentNullException>();
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceAuthorizationSuccessEvent"/> class.
/// </summary>
/// <param name="response">The response.</param>
/// <param name="request">The request.</param>
public DeviceAuthorizationSuccessEvent(DeviceAuthorizationResponse response, DeviceAuthorizationRequestValidationResult request)
: this()
{
ClientId = request.ValidatedRequest.Client?.ClientId;
ClientName = request.ValidatedRequest.Client?.ClientName;
Endpoint = Constants.EndpointNames.DeviceAuthorization;
Scopes = request.ValidatedRequest.ValidatedResources?.RawScopeValues.ToSpaceSeparatedString();
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceAuthorizationFailureEvent"/> class.
/// </summary>
/// <param name="result">The result.</param>
public DeviceAuthorizationFailureEvent(DeviceAuthorizationRequestValidationResult result)
: this()
{
if (result.ValidatedRequest != null)
{
ClientId = result.ValidatedRequest.Client?.ClientId;
ClientName = result.ValidatedRequest.Client?.ClientName;
Scopes = result.ValidatedRequest.RequestedScopes?.ToSpaceSeparatedString();
}
Endpoint = Constants.EndpointNames.DeviceAuthorization;
Error = result.Error;
ErrorDescription = result.ErrorDescription;
}
public DeviceAuthorizationResponseGeneratorTests()
{
testResult = new DeviceAuthorizationRequestValidationResult(new ValidatedDeviceAuthorizationRequest
{
Client = new Client {
ClientId = Guid.NewGuid().ToString()
},
IsOpenIdRequest = true,
ValidatedResources = new ResourceValidationResult()
});
generator = new DeviceAuthorizationResponseGenerator(
options,
new DefaultUserCodeService(new IUserCodeGenerator[] { new NumericUserCodeGenerator(), fakeUserCodeGenerator }),
deviceFlowCodeService,
clock,
new NullLogger <DeviceAuthorizationResponseGenerator>());
}
private void LogResponse(DeviceAuthorizationResponse response, DeviceAuthorizationRequestValidationResult requestResult)
{
var clientId = $"{requestResult.ValidatedRequest.Client.ClientId} ({requestResult.ValidatedRequest.Client?.ClientName ?? "no name set"})";
if (response.DeviceCode != null)
{
_logger.LogTrace("Device code issued for {clientId}: {deviceCode}", clientId, response.DeviceCode);
}
if (response.UserCode != null)
{
_logger.LogTrace("User code issued for {clientId}: {userCode}", clientId, response.UserCode);
}
if (response.VerificationUri != null)
{
_logger.LogTrace("Verification URI issued for {clientId}: {verificationUri}", clientId, response.VerificationUri);
}
if (response.VerificationUriComplete != null)
{
_logger.LogTrace("Verification URI (Complete) issued for {clientId}: {verificationUriComplete}", clientId, response.VerificationUriComplete);
}
}
public DeviceAuthorizationResponseGeneratorTests()
{
var resourceStore = new InMemoryResourcesStore(identityResources, apiResources);
var scopeValidator = new ScopeValidator(resourceStore, new NullLogger <ScopeValidator>());
testResult = new DeviceAuthorizationRequestValidationResult(new ValidatedDeviceAuthorizationRequest
{
Client = new Client {
ClientId = Guid.NewGuid().ToString()
},
IsOpenIdRequest = true,
ValidatedScopes = scopeValidator
});
generator = new DeviceAuthorizationResponseGenerator(
options,
new DefaultUserCodeService(new IUserCodeGenerator[] { new NumericUserCodeGenerator(), fakeUserCodeGenerator }),
deviceFlowCodeService,
clock,
new NullLogger <DeviceAuthorizationResponseGenerator>());
}
/// <summary>
/// Processes the response.
/// </summary>
/// <param name="validationResult">The validation result.</param>
/// <param name="baseUrl">The base URL.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">validationResult or Client</exception>
/// <exception cref="ArgumentException">Value cannot be null or whitespace. - baseUrl</exception>
public virtual async Task <DeviceAuthorizationResponse> ProcessAsync(DeviceAuthorizationRequestValidationResult validationResult, string baseUrl)
{
if (validationResult == null)
{
throw new ArgumentNullException(nameof(validationResult));
}
if (validationResult.ValidatedRequest.Client == null)
{
throw new ArgumentNullException(nameof(validationResult.ValidatedRequest.Client));
}
if (string.IsNullOrWhiteSpace(baseUrl))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(baseUrl));
}
Logger.LogTrace("Creating response for device authorization request");
var response = new DeviceAuthorizationResponse();
// generate user_code
var userCodeGenerator = await UserCodeService.GetGenerator(
validationResult.ValidatedRequest.Client.UserCodeType ??
Options.DeviceFlow.DefaultUserCodeType);
var retryCount = 0;
while (retryCount < userCodeGenerator.RetryLimit)
{
var userCode = await userCodeGenerator.GenerateAsync();
var deviceCode = await DeviceFlowCodeService.FindByUserCodeAsync(userCode);
if (deviceCode == null)
{
response.UserCode = userCode;
break;
}
retryCount++;
}
if (response.UserCode == null)
{
throw new InvalidOperationException("Unable to create unique device flow user code");
}
// generate verification URIs
response.VerificationUri = Options.UserInteraction.DeviceVerificationUrl;
if (response.VerificationUri.IsLocalUrl())
{
// if url is relative, parse absolute URL
response.VerificationUri = baseUrl.RemoveTrailingSlash() + Options.UserInteraction.DeviceVerificationUrl;
}
if (!string.IsNullOrWhiteSpace(Options.UserInteraction.DeviceVerificationUserCodeParameter))
{
response.VerificationUriComplete =
$"{response.VerificationUri}?{Options.UserInteraction.DeviceVerificationUserCodeParameter}={response.UserCode}";
}
// expiration
response.DeviceCodeLifetime = validationResult.ValidatedRequest.Client.DeviceCodeLifetime;
// interval
response.Interval = Options.DeviceFlow.Interval;
// store device request (device code & user code)
response.DeviceCode = await DeviceFlowCodeService.StoreDeviceAuthorizationAsync(response.UserCode, new DeviceCode
{
ClientId = validationResult.ValidatedRequest.Client.ClientId,
IsOpenId = validationResult.ValidatedRequest.IsOpenIdRequest,
Lifetime = response.DeviceCodeLifetime,
CreationTime = Clock.UtcNow.UtcDateTime,
RequestedScopes = validationResult.ValidatedRequest.ValidatedResources.ScopeValues
});
return(response);
}
