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); }