public async Task WithAuthUrlTokenRequest_GetsResultAndPostToRetrieveToken()
{
var rest = GetRestClient();
var options = new AuthOptions {
AuthUrl = new Uri("http://authUrl")
};
List <AblyRequest> requests = new List <AblyRequest>();
var requestData = new TokenRequest {
KeyName = KeyId, Capability = new Capability(), Mac = "mac"
};
rest.ExecuteHttpRequest = (x) =>
{
requests.Add(x);
if (x.Url == options.AuthUrl.ToString())
{
return(JsonHelper.Serialize(requestData).ToAblyResponse());
}
return(DummyTokenResponse.ToTask());
};
var tokenParams = new TokenParams {
Capability = new Capability()
};
await rest.Auth.RequestTokenAsync(tokenParams, options);
requests.Count.Should().Be(2);
var last = requests.Last().PostData as TokenRequest;
last.Should().BeEquivalentTo(requestData);
}
public async Task Authorize_WillObtainServerTimeAndPersistTheOffsetFromTheLocalClock()
{
var client = GetRestClient();
bool serverTimeCalled = false;
// configure the AblyAuth test wrapper to return UTC+30m when ServerTime() is called
// (By default the library uses DateTimeOffset.UtcNow whe Now() is called)
var testAblyAuth = new TestAblyAuth(client.Options, client, () =>
{
serverTimeCalled = true;
return(Task.FromResult(DateTimeOffset.UtcNow.AddMinutes(30)));
});
// RSA10k: If the AuthOption argument’s queryTime attribute is true
// it will obtain the server time once and persist the offset from the local clock.
var tokenParams = new TokenParams();
testAblyAuth.Options.QueryTime = true;
await testAblyAuth.AuthorizeAsync(tokenParams);
serverTimeCalled.Should().BeTrue();
testAblyAuth.GetServerNow().Should().HaveValue();
const int precision = 1000;
testAblyAuth.GetServerNow()?.Should().BeCloseTo(await testAblyAuth.GetServerTime(), TimeSpan.FromMilliseconds(precision)); // Allow 1s clock skew
testAblyAuth.GetServerNow()?.Should().BeCloseTo(DateTimeOffset.UtcNow.AddMinutes(30), TimeSpan.FromMilliseconds(precision)); // Allow 1s clock skew
}
public string Get([FromBody] TokenParams token)
{
try
{
using (GamesManagementServiceClient gmsClient = new GamesManagementServiceClient())
{
return(gmsClient.FindMatch(token.Token));
}
}
catch (FaultException <GamesManagementFault> ex)
{
if (ex.Detail.FaultType == GamesManagementFault.GamesManagementFaultType.TokenExpired)
{
throw new HttpResponseException(SetHttpErrorMsg("Token Expired. Re-login.", HttpStatusCode.Unauthorized));
}
else if (ex.Detail.FaultType == GamesManagementFault.GamesManagementFaultType.InvalidSignature)
{
throw new HttpResponseException(SetHttpErrorMsg("Invalid Token Signature.", HttpStatusCode.Unauthorized));
}
else
{
throw new HttpResponseException(SetHttpErrorMsg("Internal Server Error.", HttpStatusCode.InternalServerError));
}
}
}
private async Task <TokenRequest> CreateTokenRequest(
AblyRest client,
TokenParams @params = null,
AuthOptions options = null)
{
return(JsonHelper.Deserialize <TokenRequest>(await client.Auth.CreateTokenRequestAsync(@params, options)));
}
public async Task WithAuthUrlWhenTokenIsReturned_ReturnsToken()
{
var rest = GetRestClient();
var options = new AuthOptions {
AuthUrl = new Uri("http://authUrl")
};
var dateTime = DateTimeOffset.UtcNow;
rest.ExecuteHttpRequest = (x) =>
{
if (x.Url == options.AuthUrl.ToString())
{
return(("{ " + "\"keyName\":\"123\"," + "\"expires\":" + dateTime.ToUnixTimeInMilliseconds()
+ "," + "\"issued\":" + dateTime.ToUnixTimeInMilliseconds() + ","
+ "\"capability\":\"{}\"," + "\"clientId\":\"111\"" + "}").ToAblyResponse());
}
return("{}".ToAblyResponse());
};
var tokenRequest = new TokenParams {
Capability = new Capability()
};
var token = await rest.Auth.RequestTokenAsync(tokenRequest, options);
token.Should().NotBeNull();
dateTime.Should().BeCloseTo(token.Issued, TimeSpan.FromSeconds(1));
}
public void Delete([FromBody] TokenParams token, Int64 gameId)
{
try
{
using (GamesManagementServiceClient gmsClient = new GamesManagementServiceClient())
{
Game game = new Game()
{
GameId = gameId
};
gmsClient.DeleteGame(game, token.Token);
}
}
catch (FaultException <GamesManagementFault> ex)
{
if (ex.Detail.FaultType == GamesManagementFault.GamesManagementFaultType.TokenExpired)
{
throw new HttpResponseException(SetHttpErrorMsg("Token Expired. Re-login.", HttpStatusCode.Unauthorized));
}
else if (ex.Detail.FaultType == GamesManagementFault.GamesManagementFaultType.InvalidSignature)
{
throw new HttpResponseException(SetHttpErrorMsg("Invalid Token Signature.", HttpStatusCode.Unauthorized));
}
else
{
throw new HttpResponseException(SetHttpErrorMsg("Internal Server Error.", HttpStatusCode.InternalServerError));
}
}
}
public async Task RequestToken_WithQueryTime_SendsTimeRequestAndUsesReturnedTimeForTheRequest()
{
var rest = GetRestClient();
var currentTime = DateTimeOffset.UtcNow;
rest.ExecuteHttpRequest = x =>
{
if (x.Url.Contains("time"))
{
return(("[" + currentTime.ToUnixTimeInMilliseconds() + "]").ToAblyJsonResponse());
}
// Assert
var data = x.PostData as TokenRequest;
data.Timestamp.Should().BeCloseTo(currentTime, TimeSpan.FromMilliseconds(100));
return(DummyTokenResponse.ToTask());
};
var tokenParams = new TokenParams
{
Capability = new Capability(),
ClientId = "ClientId",
Ttl = TimeSpan.FromMinutes(10)
};
// Act
await rest.Auth.RequestTokenAsync(
tokenParams,
AuthOptions.FromExisting(rest.Options).Merge(new AuthOptions {
QueryTime = true
}));
}
public async Task ShouldKeepCurrentTokenParamsAndOptionsEvenIfCurrentTokenIsValidAndNoNewTokenIsRequested()
{
var client = GetRestClient(
null,
opts => opts.TokenDetails = new TokenDetails("boo")
{
Expires = Now.AddHours(10)
});
var testAblyAuth = new TestAblyAuth(client.Options, client);
var customTokenParams = TokenParams.WithDefaultsApplied();
customTokenParams.Ttl = TimeSpan.FromHours(2);
customTokenParams.Timestamp = Now.AddHours(1);
var customAuthOptions = AuthOptions.FromExisting(testAblyAuth.Options);
customAuthOptions.UseTokenAuth = true;
await testAblyAuth.AuthorizeAsync(customTokenParams, customAuthOptions);
var expectedTokenParams = customTokenParams.Clone();
expectedTokenParams.Timestamp = null;
testAblyAuth.CurrentTokenParams.Should().BeEquivalentTo(expectedTokenParams);
testAblyAuth.CurrentAuthOptions.Should().BeSameAs(customAuthOptions);
}
public async Task WithDefaultTokenParamsAndTokenParamsSpecified_ShouldUseOnlyParamsPassedIntoTheMethod()
{
var client = GetRestClient(
null,
options => options.DefaultTokenParams = new TokenParams
{
ClientId = "123", Ttl = TimeSpan.FromHours(2)
});
var capability = new Capability();
capability.AddResource("a").AllowAll();
var methodParams = new TokenParams
{
Capability = capability,
ClientId = "999",
Ttl = TimeSpan.FromMinutes(1),
Nonce = "123",
Timestamp = Now.AddHours(1)
};
await client.Auth.RequestTokenAsync(methodParams);
var data = LastRequest.PostData as TokenRequest;
data.Capability.Should().Be(capability);
data.ClientId.Should().Be(methodParams.ClientId);
data.Ttl.Should().Be(methodParams.Ttl);
data.Nonce.Should().Be(methodParams.Nonce);
data.Timestamp.Should().Be(methodParams.Timestamp);
}
public async Task WithAuthUrlAndAuthMethodPost_SendPostRequestToAuthUrlAndPassesPostParameters()
{
var rest = GetRestClient(AuthExecuteHttpRequest, opts =>
{
opts.AuthUrl = new Uri("http://authUrl");
opts.AuthHeaders = new Dictionary <string, string> {
{ "Test", "Test" }
};
opts.AuthParams = new Dictionary <string, string> {
{ "Test", "Test" }, { "Capability", "true" }
};
opts.AuthMethod = HttpMethod.Post;
});
var tokenParams = new TokenParams()
{
Capability = new Capability()
};
await rest.Auth.RequestTokenAsync(tokenParams, null);
var expectedParams = new Dictionary <string, string>()
{
{ "capability", "" }, //Duplicate param so the value from TokenParams takes precedence
{ "Test", "Test" }
};
Assert.Equal(HttpMethod.Post, FirstRequest.Method);
Assert.Equal(rest.Options.AuthHeaders, FirstRequest.Headers);
Assert.Equal(expectedParams, FirstRequest.PostParameters);
Assert.Equal(rest.Options.AuthUrl.ToString(), FirstRequest.Url);
}
public async Task Authorize_WillObtainServerTimeAndPersist_ShouldShowValuesAreCalculated()
{
var client = GetRestClient();
// configure the AblyAuth test wrapper to return UTC+30m when ServerTime() is called
// (By default the library uses DateTimeOffset.UtcNow whe Now() is called)
var testAblyAuth = new TestAblyAuth(client.Options, client, () => Task.FromResult(DateTimeOffset.UtcNow.AddMinutes(30)));
// RSA10k: If the AuthOption argument’s queryTime attribute is true
// it will obtain the server time once and persist the offset from the local clock.
testAblyAuth.Options.QueryTime = true;
var tokenParams = new TokenParams();
testAblyAuth.Options.QueryTime = true;
await testAblyAuth.AuthorizeAsync(tokenParams);
// to show the values are calculated and not fixed
// get the current server time offset, pause for a short time,
// then get it again.
// The new value should represent a time after the first
var snapshot = testAblyAuth.GetServerNow();
await Task.Delay(500);
testAblyAuth.GetServerNow()?.Should().BeAfter(snapshot.Value);
}
public override Task <TokenDetails> RequestTokenAsync(TokenParams tokenParams = null, AuthOptions options = null)
{
RequestTokenCalled = true;
LastRequestTokenParams = tokenParams;
LastRequestAuthOptions = options;
return(base.RequestTokenAsync(tokenParams, options));
}
public void GetPostData_WhenTtlIsNotSet_SetsItToOneHourFromNow()
{
var tokenParams = new TokenParams();
var request = Populate(tokenParams);
var expectedTtl = TimeSpan.FromHours(1);
request.Ttl.Should().Be(expectedTtl);
}
public void Test_InvalidToken()
{
IJwtTokenService tokenService = new TokenGenerator(null);
TokenParams tokenParams = new TokenParams(Guid.NewGuid().ToString(), "ISSUER", "AUDIENCE");
var token = tokenService.GenerateFakeToken();
Assert.IsFalse(tokenService.Validate(token, tokenParams));
}
internal Dictionary <string, string> TokenParamsAsDictionary()
{
if (string.IsNullOrEmpty(TokenParams))
{
return(new Dictionary <string, string>());
}
var args = TokenParams.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries);
return(args.Select(StringToKeyValue).ToDictionary(pair => pair.Key, pair => pair.Value));
}
public async Task AuthSamples1()
{
AblyRealtime realtime = new AblyRealtime("{{API_KEY}}");
TokenParams tokenParams = new TokenParams {
ClientId = "Bob"
};
string tokenRequest = await realtime.Auth.CreateTokenRequestAsync(tokenParams);
/* ... issue the TokenRequest to a client ... */
}
private async Task SendRequestTokenWithValidOptions()
{
var rest = GetRestClient();
var tokenParams = new TokenParams {
Capability = new Capability(), ClientId = "ClientId", Ttl = TimeSpan.FromMinutes(10)
};
//Act
await rest.Auth.RequestTokenAsync(tokenParams, null);
}
public void Test_ValidToken()
{
IJwtTokenService tokenService = new TokenGenerator(null);
DeviceModel device = CreateDeviceModel();
TokenParams tokenParams = new TokenParams("TOKEN", "Issuer", "Audience");
var token = tokenService.Generate(device, tokenParams);
Assert.IsTrue(tokenService.Validate(token, tokenParams));
}
public async Task RequestToken_WithoutTimeStamp_SetsCurrentTimeOnTheRequest()
{
var tokenParams = new TokenParams();
var client = GetRestClient();
await client.Auth.RequestTokenAsync(tokenParams, null);
var data = LastRequest.PostData as TokenRequest;
Assert.Equal(Now, data.Timestamp);
}
public async Task RequestToken_WithoutTimeStamp_SetsCurrentTimeOnTheRequest()
{
var tokenParams = new TokenParams();
var client = GetRestClient();
await client.Auth.RequestTokenAsync(tokenParams);
var data = LastRequest.PostData as TokenRequest;
Now.Should().BeCloseTo(data.Timestamp.Value, TimeSpan.FromMilliseconds(200));
}
static TokenParams CreateTokenParams(Capability capability, TimeSpan?ttl = null)
{
var res = new TokenParams();
res.ClientId = "John";
res.Capability = capability;
if (ttl.HasValue)
{
res.Ttl = ttl.Value;
}
return(res);
}
public async Task RestWithClientId()
{
var rest = new AblyRest(new ClientOptions {
Key = "{{API_KEY}}"
});
var tokenParams = new TokenParams {
ClientId = "Bob"
};
string tokenRequest = await rest.Auth.CreateTokenRequestAsync(tokenParams);
/* ... issue the TokenRequest to a client ... */
}
public async Task WithCapabilitySpecifiedInTokenParams_ShouldPassTheJsonStringToRequest()
{
var capability = new Capability();
capability.AddResource("a").AllowAll();
var customParams = new TokenParams {
Capability = capability
};
var request = await CreateTokenRequest(Client, customParams);
request.Capability.Should().Be(capability);
}
public async Task RequestToken_WithTokenRequestWithoutCapability_SetsBlankCapability()
{
var tokenParams = new TokenParams();
var client = GetRestClient();
await client.Auth.RequestTokenAsync(tokenParams);
var data = LastRequest.PostData as TokenRequest;
Assert.Equal(Capability.AllowAll, data.Capability);
}
public void ToRequestParams_SkipsNullOrEmptyValues()
{
var @params = new TokenParams()
{
Capability = Capability.AllowAll,
Ttl = TimeSpan.FromHours(1),
};
var result = @params.ToRequestParams();
result["capability"].Should().Be(@params.Capability.ToJson());
result["ttl"].Should().Be(@params.Ttl.Value.TotalMilliseconds.ToString());
result.Keys.Should().HaveCount(2);
}
public async Task <IActionResult> Post([FromBody] TokenParams tokenParams)
{
LoginCredentials loginCredential = tokenParams.LoginCredential;
string refreshToken = tokenParams.RefreshToken;
var accessToken = await _tokenService.GetToken(loginCredential, refreshToken);
if (accessToken == null)
{
return(new UnauthorizedResult());
}
return(new JsonResult(accessToken));
}
public async Task RequestToken_WithAuthUrlWhichReturnsAnErrorThrowsAblyException()
{
var rest = GetRestClient();
var options = new AuthOptions {
AuthUrl = new Uri("http://authUrl")
};
rest.ExecuteHttpRequest = (x) => throw new AblyException("Testing");
var tokenParams = new TokenParams {
Capability = new Capability()
};
_ = await Assert.ThrowsAsync <AblyException>(() => rest.Auth.RequestTokenAsync(tokenParams, options));
}
public async Task Authorize_PreservesTokenRequestOptionsForSubsequentRequests()
{
var client = GetRestClient();
var tokenParams = TokenParams.WithDefaultsApplied();
tokenParams.Ttl = TimeSpan.FromMinutes(260);
await client.Auth.AuthorizeAsync(tokenParams);
await client.Auth.AuthorizeAsync();
var data = LastRequest.PostData as TokenRequest;
client.AblyAuth.CurrentTokenParams.Should().BeEquivalentTo(tokenParams);
data.Ttl.Should().Be(TimeSpan.FromMinutes(260));
}
public async Task RequestToken_TimeStamp_SetsTimestampOnTheDataRequest()
{
var date = new DateTimeOffset(2014, 1, 1, 0, 0, 0, TimeSpan.Zero);
var tokenParams = new TokenParams {
Timestamp = date
};
var client = GetRestClient();
await client.Auth.RequestTokenAsync(tokenParams);
var data = LastRequest.PostData as TokenRequest;
date.Should().BeCloseTo(data.Timestamp.Value, TimeSpan.FromMilliseconds(20));
}
public async Task RequestToken_TimeStamp_SetsTimestampOnTheDataRequest()
{
var date = new DateTimeOffset(2014, 1, 1, 0, 0, 0, TimeSpan.Zero);
var tokenParams = new TokenParams()
{
Timestamp = date
};
var client = GetRestClient();
await client.Auth.RequestTokenAsync(tokenParams, null);
var data = LastRequest.PostData as TokenRequest;
Assert.Equal(date, data.Timestamp);
}
