public void RemoveAsync_WhenSubIdAndClientIdOfExistingReceived_ExpectGrantDeleted()
{
var store = new PersistedGrantStore(new TestOptions(), new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.StoreAsync(persistedGrant).Wait();
store.RemoveAllAsync(persistedGrant.SubjectId, persistedGrant.ClientId).Wait();
var foundGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.Null(foundGrant);
}
public void RemoveAsync_WhenKeyOfExistingReceived_ExpectGrantDeleted()
{
var store = new PersistedGrantStore(StoreOptions, new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.StoreAsync(persistedGrant).Wait();
store.RemoveAsync(persistedGrant.Key).Wait();
var foundGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.Null(foundGrant);
}
public void GetAsync_WithSubAndTypeAndPersistedGrantExists_ExpectPersistedGrantReturned()
{
var store = new PersistedGrantStore(new TestOptions(), new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.StoreAsync(persistedGrant).Wait();
var foundPersistedGrants = store.GetAllAsync(persistedGrant.SubjectId).Result.ToList();
Assert.NotNull(foundPersistedGrants);
Assert.NotEmpty(foundPersistedGrants);
Assert.Equal(1, foundPersistedGrants.Count);
Assert.Equal(persistedGrant.SubjectId, foundPersistedGrants[0].SubjectId);
}
public async Task Can_call_PersistedGrantStore_RemoveAsync()
=> await ExecuteWithStrategyInTransactionAsync(
async context =>
{
await SaveGrants(context);
},
async context =>
{
var store = new PersistedGrantStore(context, new FakeLogger <PersistedGrantStore>());
await store.RemoveAsync("K2");
Assert.Null(await store.GetAsync("K2"));
await store.RemoveAsync("???");
}
);
private static async Task SaveGrants(PersistedGrantDbContext context)
{
var store = new PersistedGrantStore(context, new FakeLogger <PersistedGrantStore>());
await store.StoreAsync(
new PersistedGrant
{
Key = "K1",
Type = "T1",
SubjectId = "Su1",
SessionId = "Se1",
ClientId = "C1",
Description = "D1",
CreationTime = DateTime.Now,
Expiration = null,
ConsumedTime = null,
Data = "Data1"
});
await store.StoreAsync(
new PersistedGrant
{
Key = "K2",
Type = "T1",
SubjectId = "Su1",
SessionId = "Se1",
ClientId = "C2",
Description = "D2",
CreationTime = DateTime.Now,
Expiration = DateTime.Now + new TimeSpan(1, 0, 0, 0),
ConsumedTime = null,
Data = "Data2"
});
await store.StoreAsync(
new PersistedGrant
{
Key = "K3",
Type = "T2",
SubjectId = "Su2",
SessionId = "Se2",
ClientId = "C1",
Description = "D3",
CreationTime = DateTime.Now,
Expiration = null,
ConsumedTime = null,
Data = "Data3"
});
}
public async Task GetAllAsync_WithSubAndTypeAndPersistedGrantExists_ExpectPersistedGrantReturned()
{
var persistedGrant = CreateTestObject();
await _context.PersistedGrants.Document(persistedGrant.Key).SetAsync(persistedGrant.ToEntity());
IList <PersistedGrant> foundPersistedGrants;
var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create());
foundPersistedGrants = (await store.GetAllAsync(new PersistedGrantFilter {
SubjectId = persistedGrant.SubjectId
})).ToList();
Assert.NotNull(foundPersistedGrants);
Assert.NotEmpty(foundPersistedGrants);
}
public void Store_should_create_new_record_if_key_does_not_exist()
{
var store = new PersistedGrantStore(new TestOptions(), new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.RemoveAsync(persistedGrant.Key).Wait();
var missingGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.Null(missingGrant);
store.StoreAsync(persistedGrant).Wait();
var foundGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.NotNull(foundGrant);
}
public void StoreAsync_WhenPersistedGrantStored_ExpectSuccess()
{
var persistedGrant = GenFu.GenFu.New <PersistedGrant>();
using (var session = martenFixture.Store.OpenSession())
{
var store = new PersistedGrantStore(session);
store.StoreAsync(persistedGrant.ToModel()).Wait();
}
using (var session = martenFixture.Store.OpenSession())
{
var foundGrant = session.Query <PersistedGrant>().First();
Assert.NotNull(foundGrant);
}
}
public void GetAsync_WithKeyAndPersistedGrantExists_ExpectPersistedGrantReturned()
{
var persistedGrant = GenFu.GenFu.New <PersistedGrant>();
using (var session = martenFixture.Store.OpenSession())
{
var store = new PersistedGrantStore(session);
store.StoreAsync(persistedGrant.ToModel()).Wait();
}
using (var session = martenFixture.Store.OpenSession())
{
var store = new PersistedGrantStore(session);
var foundGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.NotNull(foundGrant);
}
}
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess(DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var store = new PersistedGrantStore(context, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
}
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
public async Task RemoveAllAsync_WhenSubIdAndClientIdOfExistingReceived_ExpectGrantDeleted()
{
var persistedGrant = CreateTestObject();
await _context.PersistedGrants.Document(persistedGrant.Key).SetAsync(persistedGrant.ToEntity());
var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create());
await store.RemoveAllAsync(new PersistedGrantFilter
{
SubjectId = persistedGrant.SubjectId,
ClientId = persistedGrant.ClientId
});
var foundGrant = (await _context.PersistedGrants.Document(persistedGrant.Key).GetSnapshotAsync()).ConvertTo <Entities.PersistedGrant>();
Assert.Null(foundGrant);
}
public void RemoveAsync_ShouldRemoveByKey()
{
var persistedGrant = GenFu.GenFu.New <PersistedGrant>();
using (var session = martenFixture.Store.LightweightSession())
{
session.Store(persistedGrant);
session.SaveChanges();
}
using (var session = martenFixture.Store.LightweightSession())
{
var _store = new PersistedGrantStore(session);
_store.RemoveAsync(persistedGrant.Key).Wait();
var grant = session.Query <PersistedGrant>().FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.Null(grant);
}
}
public void RemoveAllAsync_ShouldRemoveAllGrantsBySubjectAndClientIdAndType()
{
var persistedGrant = GenFu.GenFu.New <PersistedGrant>();
using (var session = martenFixture.Store.LightweightSession())
{
session.Store(persistedGrant);
session.SaveChanges();
}
using (var session = martenFixture.Store.LightweightSession())
{
var _store = new PersistedGrantStore(session);
_store.RemoveAllAsync(persistedGrant.SubjectId, persistedGrant.ClientId, persistedGrant.Type).Wait();
var grants = session.Query <PersistedGrant>().Where(x => x.SubjectId == persistedGrant.SubjectId && x.ClientId == persistedGrant.ClientId && x.Type == persistedGrant.Type).ToList();
Assert.True(grants.Count == 0);
}
}
/// <summary>
/// Constructor for TokenCleanupService.
/// </summary>
/// <param name="options"></param>
/// <param name="persistedGrantStore"></param>
/// <param name="operationalStoreNotification"></param>
/// <param name="logger"></param>
public TokenCleanupService(
OperationalStoreOptions options,
IPersistedGrantStore persistedGrantStore,
ILogger <TokenCleanupService> logger,
IPersistedGrantStoreNotification operationalStoreNotification = null)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
if (_options.TokenCleanupBatchSize < 1)
{
throw new ArgumentException("Token cleanup batch size interval must be at least 1");
}
_persistedGrantStore = persistedGrantStore as PersistedGrantStore ?? throw new ArgumentNullException(nameof(persistedGrantStore));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_operationalStoreNotification = operationalStoreNotification;
}
public async Task Store_should_update_record_if_key_already_exists()
{
var persistedGrant = CreateTestObject();
await _context.PersistedGrants.AddAsync(persistedGrant.ToEntity());
var newDate = persistedGrant.Expiration.Value.AddHours(1);
var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create());
persistedGrant.Expiration = newDate;
await store.StoreAsync(persistedGrant);
var foundGrant = (await _context.PersistedGrants.WhereEqualTo("Key", persistedGrant.Key).GetSnapshotAsync())[0].ConvertTo <Entities.PersistedGrant>();
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess(ISessionFactory sessionFactory)
{
var persistedGrant = CreateTestObject();
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
var store = new PersistedGrantStore(provider);
await store.StoreAsync(persistedGrant);
}
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
var foundGrant = await provider.Session.GetAsync <Entities.PersistedGrant>(persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
public async Task RemoveAsync_WhenKeyOfExistingReceived_ExpectGrantDeleted()
{
var persistedGrant = CreateTestObject();
var repo = g.operationalDb.GetRepository <Storage.Entities.PersistedGrant>();
var entity = persistedGrant.ToEntity();
repo.Insert(entity);
var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create());
await store.RemoveAsync(persistedGrant.Key);
var foundGrant = repo.Select.Where(x => x.Key == persistedGrant.Key).First();
Assert.Null(foundGrant);
}
public async Task Store_should_create_new_record_if_key_does_not_exist()
{
var persistedGrant = CreateTestObject();
var repo = g.operationalDb.GetRepository <Storage.Entities.PersistedGrant>();
var foundGrant = repo.Select.Where(x => x.Key == persistedGrant.Key).First();
Assert.Null(foundGrant);
var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
var foundGrant2 = repo.Select.Where(x => x.Key == persistedGrant.Key).First();
Assert.NotNull(foundGrant2);
}
public async Task Store_should_create_new_record_if_key_does_not_exist()
{
var persistedGrant = CreateTestObject();
var foundGrant = (await _context.PersistedGrants
.WhereEqualTo("Key", persistedGrant.Key)
.GetSnapshotAsync()).FirstOrDefault()?.ConvertTo <Entities.PersistedGrant>();
Assert.Null(foundGrant);
var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
foundGrant = (await _context.PersistedGrants
.WhereEqualTo("Key", persistedGrant.Key)
.GetSnapshotAsync())[0].ConvertTo <Entities.PersistedGrant>();
Assert.NotNull(foundGrant);
}
public async Task Should_Store_New_Grant(TestDatabase testDb)
{
var testGrant = CreateTestGrant();
var loggerMock = new Mock <ILogger <PersistedGrantStore> >();
using (var session = testDb.OpenSession())
{
var store = new PersistedGrantStore(session, loggerMock.Object);
await store.StoreAsync(testGrant);
}
using (var session = testDb.OpenSession())
{
(await session.GetAsync <Entities.PersistedGrant>(testGrant.Key)).Should().NotBeNull();
}
await CleanupTestDataAsync(testDb);
}
public void Store_should_update_record_if_key_already_exists()
{
var store = new PersistedGrantStore(new TestOptions(), new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.StoreAsync(persistedGrant).Wait();
var newDate = persistedGrant.Expiration.Value.AddHours(1);
persistedGrant.Expiration = newDate;
store.StoreAsync(persistedGrant).Wait();
var foundGrant = store.GetAsync(persistedGrant.Key).Result;
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
public async Task GetAsync_WithKeyAndPersistedGrantExists_ExpectPersistedGrantReturned()
{
var persistedGrant = CreateTestObject();
var repo = g.operationalDb.GetRepository <Storage.Entities.PersistedGrant>();
var entity = persistedGrant.ToEntity();
repo.Insert(entity);
PersistedGrant foundPersistedGrant;
var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create());
foundPersistedGrant = await store.GetAsync(persistedGrant.Key);
Assert.NotNull(foundPersistedGrant);
}
public async Task PersistedGrantStore_RemoveSubjectClientTypeTest()
{
var storageContext = Services.BuildServiceProvider().GetService <PersistedGrantStorageContext>();
Assert.IsNotNull(storageContext);
var store = new PersistedGrantStore(storageContext, _logger);
Assert.IsNotNull(store);
string subject = Guid.NewGuid().ToString();
string client = Guid.NewGuid().ToString();
string type = Guid.NewGuid().ToString();
List <PersistedGrant> grants = new List <PersistedGrant>();
for (int iCounter = 0; iCounter < 10; iCounter++)
{
var grant = CreateTestObject(subjectId: subject, clientId: client, type: type);
Console.WriteLine(JsonConvert.SerializeObject(grant));
await store.StoreAsync(grant);
grants.Add(grant);
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var returnGrants = (await store.GetAllAsync(subject)).Where(w => w.ClientId == client && w.Type == type).ToList();
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.GetAllAsync({subject}): {stopwatch.ElapsedMilliseconds} ms");
Assert.AreEqual <int>(grants.Count, returnGrants.Count);
grants.ForEach(g => AssertGrantsEqual(g, returnGrants.FirstOrDefault(f => f.Key == g.Key)));
stopwatch.Reset();
stopwatch.Start();
await store.RemoveAllAsync(subject, client, type);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.RemoveAllAsync({subject}, {client}, {type}): {stopwatch.ElapsedMilliseconds} ms");
returnGrants = (await store.GetAllAsync(subject)).Where(w => w.ClientId == client && w.Type == type).ToList();
Assert.AreEqual <int>(0, returnGrants.Count);
}
public async Task GetAsync_WithKeyAndPersistedGrantExists_ExpectPersistedGrantReturned(ISessionFactory sessionFactory)
{
var persistedGrant = CreateTestObject();
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
await provider.Session.SaveAsync(_mapper.Map <Entities.PersistedGrant>(persistedGrant));
}
PersistedGrant foundPersistedGrant;
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
var store = new PersistedGrantStore(provider);
foundPersistedGrant = await store.GetAsync(persistedGrant.Key);
}
Assert.NotNull(foundPersistedGrant);
}
public async void ShouldStoreToken()
{
//Arrange
for (int i = 0; i < 10; i++)
{
var token = new PersistedGrant
{
Key = "key" + i,
ClientId = "clientId" + i,
CreationTime = DateTime.Now,
Expiration = DateTime.Now.AddDays(1),
SubjectId = "subjectId" + i,
Data = "data" + i,
Type = "type" + i,
};
await PersistedGrantStore.StoreAsync(token);
}
}
public async Task PersistedGrantStore_RemoveByKeyNegativeTest()
{
var storageContext = Services.BuildServiceProvider().GetService <PersistedGrantStorageContext>();
Assert.IsNotNull(storageContext);
var store = new PersistedGrantStore(storageContext, _logger);
Assert.IsNotNull(store);
string key = Guid.NewGuid().ToString();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
await store.RemoveAsync(key);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.RemoveAsync({key}): {stopwatch.ElapsedMilliseconds} ms");
}
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess()
{
var storeHolder = GetOperationalDocumentStoreHolder();
var persistedGrant = CreateTestObject();
var store = new PersistedGrantStore(storeHolder, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var hashedTokenKey = CryptographyHelper.CreateHash(persistedGrant.Key);
using (var session = storeHolder.OpenAsyncSession())
{
var foundGrant = await session.Query <PersistedGrant>().FirstOrDefaultAsync(x => x.Key == hashedTokenKey);
Assert.NotNull(foundGrant);
}
}
public async Task RemoveAllAsync_WhenSubIdClientIdAndTypeOfExistingReceived_ExpectGrantDeleted()
{
var persistedGrant = CreateTestObject();
var repo = g.operationalDb.GetRepository <Storage.Entities.PersistedGrant>();
var entity = persistedGrant.ToEntity();
var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create());
await store.RemoveAllAsync(new PersistedGrantFilter
{
SubjectId = persistedGrant.SubjectId,
ClientId = persistedGrant.ClientId,
Type = persistedGrant.Type
});
var foundGrant = repo.Select.Where(x => x.Key == persistedGrant.Key).First();
Assert.Null(foundGrant);
}
public async Task GetAsync_WithKeyAndPersistedGrantExists_ExpectPersistedGrantReturned(DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
context.PersistedGrants.Add(persistedGrant.ToEntity());
context.SaveChanges();
}
PersistedGrant foundPersistedGrant;
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var store = new PersistedGrantStore(context, FakeLogger <PersistedGrantStore> .Create());
foundPersistedGrant = await store.GetAsync(persistedGrant.Key);
}
Assert.NotNull(foundPersistedGrant);
}
public void GetAllAsync_ShouldReturnSavedGrants()
{
int count = 10;
string subject = Guid.NewGuid().ToString();
GenFu.GenFu.Configure <PersistedGrant>().Fill(x => x.SubjectId, subject);
var persistedGrants = GenFu.GenFu.ListOf <PersistedGrant>(count);
using (var session = martenFixture.Store.LightweightSession())
{
session.StoreObjects(persistedGrants);
session.SaveChanges();
}
using (var session = martenFixture.Store.LightweightSession())
{
var _store = new PersistedGrantStore(session);
var foundGrants = _store.GetAllAsync(subject).Result;
Assert.True(foundGrants.Count() == count);
}
}
