public void TokenCleanup() { IPersistedGrantStore store = Fixture.GetService <IPersistedGrantStore>(); IHostedService svc = Fixture.GetService <IHostedService>(); Client client = CreateClient(); Provider.AddClientAsync(client).Wait(); svc.StartAsync(default(CancellationToken)).Wait(); PersistedGrant grant1 = CreateGrant(client.ClientId, "aaa", "t1"); PersistedGrant grant2 = CreateGrant(client.ClientId, "aaa"); grant1.Expiration = DateTime.Now.Add(TimeSpan.FromSeconds(15)); grant2.Expiration = DateTime.Now.Add(TimeSpan.FromSeconds(25)); store.StoreAsync(grant1).Wait(); store.StoreAsync(grant2).Wait(); List <PersistedGrant> results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Equal(2, results.Count); Task.Delay(20000).Wait(); results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Equal(1, results.Count); Task.Delay(10000).Wait(); results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Equal(0, results.Count); }
public async Task Store_Grant_And_Retrieve_It() { var key = Guid.NewGuid().ToString("N"); var grant = new IdentityServer4.Models.PersistedGrant { Key = key, Expiration = DateTime.UtcNow.AddDays(1), Type = "test", ClientId = "client1", SubjectId = "sub1", SessionId = "session1", CreationTime = DateTime.UtcNow, Description = "des", Data = "bla bla", ConsumedTime = DateTime.UtcNow }; await persistedGrantStore.StoreAsync(grant); var item = await persistedGrantStore.GetAsync(key); item.Should().NotBeNull(); item.Key.Should().Be(key); item.Type.Should().Be(grant.Type); item.ClientId.Should().Be(grant.ClientId); item.SubjectId.Should().Be(grant.SubjectId); item.Data.Should().Be(grant.Data); item.Description.Should().Be(grant.Description); item.SessionId.Should().Be(grant.SessionId); item.CreationTime.Should().NotBe(new DateTime()); item.Expiration.Should().NotBeNull(); item.ConsumedTime.Should().NotBeNull(); }
public void PersistedGrantStore() { IPersistedGrantStore store = Fixture.GetService <IPersistedGrantStore>(); Client client = CreateClient(); Provider.AddClientAsync(client).Wait(); PersistedGrant grant1 = CreateGrant(client.ClientId, "aaa", "t1"); PersistedGrant grant2 = CreateGrant(client.ClientId, "aaa"); PersistedGrant grant3 = CreateGrant(client.ClientId, "aaa"); PersistedGrant grant4 = CreateGrant(client.ClientId); PersistedGrant grant5 = CreateGrant(client.ClientId); store.StoreAsync(grant1).Wait(); store.StoreAsync(grant2).Wait(); store.StoreAsync(grant3).Wait(); store.StoreAsync(grant4).Wait(); store.StoreAsync(grant5).Wait(); List <PersistedGrant> results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Equal(3, results.Count); store.RemoveAllAsync("aaa", grant1.ClientId, "t1").Wait(); results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Equal(2, results.Count); store.RemoveAllAsync("aaa", grant1.ClientId).Wait(); results = store.GetAllAsync("aaa").Result?.ToList(); Assert.Empty(results); PersistedGrant result = store.GetAsync(grant5.Key).Result; Assert.NotNull(result); store.RemoveAsync(grant5.Key); result = store.GetAsync(grant5.Key).Result; Assert.Null(result); }
public async Task StoreAsync(PersistedGrant grant) { object obj; if (_scopedStorage.TryGetValue(Constants.ScopedRequestType.ExtensionGrantValidationContext, out obj)) { var extensionGrantValidationContext = obj as ExtensionGrantValidationContext; if (extensionGrantValidationContext.Request.GrantType == FluffyBunny4.Constants.GrantType.TokenExchange) { if (grant.Type != IdentityServerConstants.PersistedGrantTypes.RefreshToken) { var offlineAccess = extensionGrantValidationContext.Request.RequestedScopes.FirstOrDefault(scope => scope == IdentityServerConstants.StandardScopes.OfflineAccess); if (offlineAccess != null) { // refresh_token coming. so save this access_token for later storage _scopedStorage.AddOrUpdate(Constants.ScopedRequestType.AccessTokenPersistedGrant, grant); return; } // store access_token for later } else { _scopedStorage.TryGetValue(Constants.ScopedRequestType.AccessTokenPersistedGrant, out obj); var grantStored = obj as PersistedGrant; var extra = _coreMapperAccessor.Mapper.Map <PersistedGrantExtra>(grantStored); extra.RefreshTokenKey = grant.Key; await _innerPersistedGrantStore.StoreAsync(extra); extra = _coreMapperAccessor.Mapper.Map <PersistedGrantExtra>(grant); // extra.AccessTokenKey = grantStored.Key; await _innerPersistedGrantStore.StoreAsync(extra); return; } } } await _innerPersistedGrantStore.StoreAsync(grant); }
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess() { // Arrange var persistedGrant = UniquePersistedGrant; // Act await _persistedGrantStore.StoreAsync(persistedGrant); // Assert var foundPersistedGrant = await _persistedGrantStore.GetAsync(persistedGrant.Key); // Assert Assert.IsNotNull(foundPersistedGrant); }
public async Task StoreAsync_Should_Store_PersistedGrant() { //Act await _persistedGrantStore.StoreAsync(new PersistedGrant { Key = "39", ClientId = "TestClientId-39", Type = "TestType-39", SubjectId = "TestSubject", Data = "TestData-39", Expiration = new DateTime(2018, 1, 6, 21, 22, 23), CreationTime = new DateTime(2018, 1, 5, 19, 20, 21) }); //Assert var persistedGrant = await _persistedGrantStore.GetAsync("39"); persistedGrant.Key.ShouldBe("39"); persistedGrant.ClientId.ShouldBe("TestClientId-39"); persistedGrant.Type.ShouldBe("TestType-39"); persistedGrant.SubjectId.ShouldBe("TestSubject"); persistedGrant.Data.ShouldBe("TestData-39"); persistedGrant.Expiration.HasValue.ShouldBe(true); persistedGrant.Expiration.Value.Year.ShouldBe(2018); persistedGrant.Expiration.Value.Month.ShouldBe(1); persistedGrant.Expiration.Value.Day.ShouldBe(6); persistedGrant.Expiration.Value.Hour.ShouldBe(21); persistedGrant.Expiration.Value.Minute.ShouldBe(22); persistedGrant.Expiration.Value.Second.ShouldBe(23); persistedGrant.CreationTime.Year.ShouldBe(2018); persistedGrant.CreationTime.Month.ShouldBe(1); persistedGrant.CreationTime.Day.ShouldBe(5); persistedGrant.CreationTime.Hour.ShouldBe(19); persistedGrant.CreationTime.Minute.ShouldBe(20); persistedGrant.CreationTime.Second.ShouldBe(21); }
/// <summary> /// Stores the item. /// </summary> /// <param name="key">The key.</param> /// <param name="item">The item.</param> /// <param name="clientId">The client identifier.</param> /// <param name="subjectId">The subject identifier.</param> /// <param name="created">The created.</param> /// <param name="expiration">The expiration.</param> /// <returns></returns> protected async Task StoreItemAsync(string key, T item, string clientId, string subjectId, DateTime created, DateTime?expiration) { key = GetHashedKey(key); var json = _serializer.Serialize(item); var grant = new PersistedGrant { Key = key, Type = _grantType, ClientId = clientId, SubjectId = subjectId, CreationTime = created, Expiration = expiration, Data = json }; await _store.StoreAsync(grant); }
async Task StoreItem <T>(string key, T item, string type, string clientId, string subjectId, DateTime created, int lifetime) { key = HashKey(key, type); var json = _serializer.Serialize(item); var grant = new PersistedGrant { Key = key, Type = type, ClientId = clientId, SubjectId = subjectId, CreationTime = created, Expiration = created.AddSeconds(lifetime), Data = json }; await _store.StoreAsync(grant); }
async Task StoreAsync(PersistedGrant persistedGrant) { await _persistedGrantStore.StoreAsync(persistedGrant); }
public Task StoreAsync(PersistedGrant grant) { return(_inMemoryPersistedGrantStore.StoreAsync(grant)); }
public Task StoreAsync(PersistedGrant grant) { return(_persistedGrantStoreImplementation.StoreAsync(grant)); }
public async Task exception_store_key_null_or_whitespace() { var ttl = 100; // 2 seconds // Act var result = new Action(() => { _currentId = NewGuidS; _currentPersistedGrant = new PersistedGrant { Key = null, ClientId = NewGuidS, CreationTime = DateTime.UtcNow, SubjectId = NewGuidS, Data = NewGuidS, Expiration = DateTime.UtcNow.AddSeconds(ttl), Type = NewGuidS }; _persistedGrantStore.StoreAsync(_currentPersistedGrant).GetAwaiter().GetResult(); }); //Assert result.Should().Throw <Exception>(); result = new Action(() => { _currentId = NewGuidS; _currentPersistedGrant = new PersistedGrant { Key = " ", ClientId = NewGuidS, CreationTime = DateTime.UtcNow, SubjectId = NewGuidS, Data = NewGuidS, Expiration = DateTime.UtcNow.AddSeconds(ttl), Type = NewGuidS }; _persistedGrantStore.StoreAsync(_currentPersistedGrant).GetAwaiter().GetResult(); }); //Assert result.Should().Throw <Exception>(); }
public async Task StoreAsync(Models.PersistedGrant grant) { try { if (grant == null) { throw new ArgumentNullException( nameof(grant), "grant cant be null"); } await _inner.StoreAsync(grant); var cacheKey = Utilities.CreateCachedPersistedGrantStoreKey(grant); var item = new CacheItem(grant.ToEntity()) { Tags = Utilities.CreateCachePersistedGrantStoreTags(grant), Expiration = Utilities.DetermineCachePersistedGrantStoreExpiration( grant, _handle.options) }; var result = await _setFallBackPolicy .ExecuteAsync(async() => { await _handle.cache.InsertAsync(cacheKey, item) .ConfigureAwait(false); return(true); }).ConfigureAwait(false); if (result) { if (_debugLoggingEnabled) { _logger.LogDebug( $"Persisted grant with key {grant.Key} " + $"successfully stored"); } } else { if (_errorLoggingEnabled) { _logger.LogError( $"Caching problems with persistant store cache"); } } } catch (Exception ex) { if (_errorLoggingEnabled) { _logger.LogError( ex, $"something went wrong with StoreAsync " + $"for grant key {grant.Key}"); } throw; } }