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 Should_Update_Grant(TestDatabase testDb)
{
var testGrant = CreateTestGrant();
var loggerMock = new Mock <ILogger <PersistedGrantStore> >();
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testGrant.ToEntity());
await session.FlushAsync();
}
var newExpirationDate = testGrant.Expiration?.AddHours(1);
using (var session = testDb.OpenSession())
{
var store = new PersistedGrantStore(session, loggerMock.Object);
testGrant.Expiration = newExpirationDate;
await store.StoreAsync(testGrant);
}
using (var session = testDb.OpenSession())
{
var foundGrant = await session.GetAsync <Entities.PersistedGrant>(testGrant.Key);
Assert.NotNull(foundGrant.Expiration);
Assert.NotNull(newExpirationDate);
foundGrant.Expiration.Value.Should().Be(newExpirationDate.Value);
}
await CleanupTestDataAsync(testDb);
}
public async Task PersistedGrantStore_ExpiredGetTest()
{
var storageContext = Services.BuildServiceProvider().GetService <PersistedGrantStorageContext>();
Assert.IsNotNull(storageContext);
var store = new PersistedGrantStore(storageContext, _logger);
Assert.IsNotNull(store);
var grant = CreateTestObject();
grant.Expiration = DateTime.UtcNow.AddHours(-1);
Console.WriteLine(JsonConvert.SerializeObject(grant));
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
await store.StoreAsync(grant);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.StoreAsync({grant.Key}): {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Reset();
stopwatch.Start();
var returnGrants = await store.StorageContext.GetExpiredAsync(1000);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStorageContext.GetExpiredAsync(): {stopwatch.ElapsedMilliseconds} ms");
AssertGrantsEqual(grant, returnGrants.FirstOrDefault(f => f.Key == grant.Key).ToModel(), false);
Assert.AreEqual <int>(2, returnGrants.Where(f => f.Key == grant.Key).Count());
}
public async Task Store_should_update_record_if_key_already_exists()
{
var storeHolder = GetOperationalDocumentStoreHolder();
var persistedGrant = CreateTestObject();
var entity = persistedGrant.ToEntity();
using (var session = storeHolder.OpenAsyncSession())
{
await session.StoreAsync(entity);
await session.SaveChangesAsync();
}
var newDate = persistedGrant.Expiration.Value.AddHours(1);
var store = new PersistedGrantStore(storeHolder, FakeLogger <PersistedGrantStore> .Create());
persistedGrant.Expiration = newDate;
await store.StoreAsync(persistedGrant);
var hashedTokenKey = CryptographyHelper.CreateHash(persistedGrant.Key);
using (var session = storeHolder.OpenAsyncSession())
{
var foundGrant = await session.Query <Storage.Entities.PersistedGrant>()
.FirstOrDefaultAsync(x => x.Key == hashedTokenKey);
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
}
public async Task PersistedGrantStore_SaveGetByKeyTest()
{
var storageContext = Services.BuildServiceProvider().GetService <PersistedGrantStorageContext>();
Assert.IsNotNull(storageContext);
var store = new PersistedGrantStore(storageContext, _logger);
Assert.IsNotNull(store);
for (int iCounter = 0; iCounter < 10; iCounter++)
{
var grant = CreateTestObject();
Console.WriteLine(JsonConvert.SerializeObject(grant));
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
await store.StoreAsync(grant);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.StoreAsync({grant.Key}): {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Reset();
//Failed Key:"78854990-6e1e-46ea-a5e0-5f26dd6c085a"
//Failed Key:"1d7e16e2-daac-4ad4-8e7d-cffa59c8d79f"
stopwatch.Start();
var returnGrant = await store.GetAsync(grant.Key);
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.GetAsync({grant.Key}): {stopwatch.ElapsedMilliseconds} ms");
AssertGrantsEqual(grant, returnGrant);
}
}
public async Task PersistedGrantStore_SaveGetBySubjectTest()
{
var storageContext = Services.BuildServiceProvider().GetService <PersistedGrantStorageContext>();
Assert.IsNotNull(storageContext);
var store = new PersistedGrantStore(storageContext, _logger);
Assert.IsNotNull(store);
string subject = Guid.NewGuid().ToString();
List <PersistedGrant> grants = new List <PersistedGrant>();
for (int iCounter = 0; iCounter < 10; iCounter++)
{
var grant = CreateTestObject(subjectId: subject);
Console.WriteLine(JsonConvert.SerializeObject(grant));
await store.StoreAsync(grant);
grants.Add(grant);
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var returnGrants = (await store.GetAllAsync(subject)).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)));
}
public async Task Store_should_update_record_if_key_already_exists()
{
using var ravenStore = GetDocumentStore();
await new PersistentGrantIndex().ExecuteAsync(ravenStore);
var persistedGrant = CreateTestObject();
using (var session = ravenStore.OpenSession())
{
session.Store(persistedGrant.ToEntity());
session.SaveChanges();
}
var newDate = persistedGrant.Expiration.Value.AddHours(1);
using (var session = ravenStore.OpenAsyncSession())
{
var store = new PersistedGrantStore(session, FakeLogger <PersistedGrantStore> .Create());
persistedGrant.Expiration = newDate;
await store.StoreAsync(persistedGrant);
}
using (var session = ravenStore.OpenSession())
{
var foundGrant = session.Query <Storage.Entities.PersistedGrant>()
.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
}
public async Task Store_should_create_new_record_if_key_does_not_exist()
{
using var ravenStore = GetDocumentStore();
await new PersistentGrantIndex().ExecuteAsync(ravenStore);
var persistedGrant = CreateTestObject();
using (var session = ravenStore.OpenSession())
{
var foundGrant = session.Query <PersistedGrant>().FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.Null(foundGrant);
}
using (var session = ravenStore.OpenAsyncSession())
{
var store = new PersistedGrantStore(session, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
}
WaitForIndexing(ravenStore);
WaitForUserToContinueTheTest(ravenStore);
using (var session = ravenStore.OpenSession())
{
var foundGrant = session.Query <PersistedGrant>()
.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
public void Store_should_create_new_record_if_key_does_not_exist(
DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context =
new PersistedGrantDbContext(options, StoreOptions))
{
var foundGrant = context.PersistedGrants
.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.Null(foundGrant);
}
using (var context =
new PersistedGrantDbContext(options, StoreOptions))
{
var store = new PersistedGrantStore(
context,
NullLogger <PersistedGrantStore> .Create()
);
store.StoreAsync(persistedGrant).Wait();
}
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var foundGrant = context.PersistedGrants
.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
public async Task Store_should_update_record_if_key_already_exists(ISessionFactory sessionFactory)
{
var persistedGrant = CreateTestObject();
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
await provider.Session.SaveAsync(_mapper.Map <Entities.PersistedGrant>(persistedGrant));
}
var newDate = persistedGrant.Expiration.Value.AddHours(1);
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
var store = new PersistedGrantStore(provider);
persistedGrant.Expiration = newDate;
await store.StoreAsync(persistedGrant);
}
using (var provider = new OperationalSessionProvider(sessionFactory.OpenSession))
{
var foundGrant = await provider.Session.GetAsync <Entities.PersistedGrant>(persistedGrant.Key);
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
}
public void StoreAsync_WhenPersistedGrantStored_ExpectSuccess(
DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context =
new PersistedGrantDbContext(options, StoreOptions))
{
var store = new PersistedGrantStore(
context,
NullLogger <PersistedGrantStore> .Create()
);
store.StoreAsync(persistedGrant).Wait();
}
using (var context =
new PersistedGrantDbContext(options, StoreOptions))
{
var foundGrant = context.PersistedGrants
.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
public async Task Store_should_update_record_if_key_already_exists(DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
context.PersistedGrants.Add(persistedGrant.ToEntity());
context.SaveChanges();
}
var newDate = persistedGrant.Expiration.Value.AddHours(1);
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var store = new PersistedGrantStore(context, FakeLogger <PersistedGrantStore> .Create());
persistedGrant.Expiration = newDate;
await store.StoreAsync(persistedGrant);
}
using (var context = new PersistedGrantDbContext(options, StoreOptions))
{
var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
Assert.Equal(newDate, persistedGrant.Expiration);
}
}
public async Task Store_should_create_new_record_if_key_does_not_exist()
{
var storeHolder = GetOperationalDocumentStoreHolder();
var persistedGrant = CreateTestObject();
var hashedTokenKey = CryptographyHelper.CreateHash(persistedGrant.Key);
using (var session = storeHolder.OpenAsyncSession())
{
var foundGrant = await session.Query <PersistedGrant>().FirstOrDefaultAsync(x => x.Key == hashedTokenKey);
Assert.Null(foundGrant);
}
var store = new PersistedGrantStore(storeHolder, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
WaitForUserToContinueTheTest(storeHolder.IntegrationTest_GetDocumentStore());
using (var session = storeHolder.OpenAsyncSession())
{
var foundGrant = await session.Query <PersistedGrant>()
.FirstOrDefaultAsync(x => x.Key == hashedTokenKey);
Assert.NotNull(foundGrant);
}
}
public async Task StoreAysnc_Stores_Entries()
{
var now = DateTime.Now;
_clock.Setup(x => x.UtcNow).Returns(now);
string key = nameof(StoreAysnc_Stores_Entries);
string expected = "this is a test";
var grant = new PersistedGrant {
Key = key, Data = expected, Expiration = now.AddSeconds(1)
};
await _store.StoreAsync(grant);
var actual = await _store.GetAsync(key);
Assert.NotNull(actual);
Assert.Equal(expected, actual.Data);
}
public async Task PersistedGrantStore_RemoveSubjectClientTypeSessionTest()
{
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();
string session = 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,
session: (session + iCounter.ToString()));
Console.WriteLine(JsonConvert.SerializeObject(grant));
await store.StoreAsync(grant);
grants.Add(grant);
}
string sessionTarget = session + "0";
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var returnGrants = (await store.GetAllAsync(new PersistedGrantFilter()
{
SubjectId = subject, ClientId = client, Type = type, SessionId = sessionTarget
})).ToList();
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.GetAllAsync({subject}, {client}, {type}, {sessionTarget}): {stopwatch.ElapsedMilliseconds} ms");
Assert.AreEqual <int>(1, returnGrants.Count);
returnGrants.ForEach(g => AssertGrantsEqual(g, grants.FirstOrDefault(f => f.Key == g.Key)));
stopwatch.Reset();
stopwatch.Start();
await store.RemoveAllAsync(new PersistedGrantFilter()
{
SubjectId = subject, ClientId = client, Type = type, SessionId = sessionTarget
});
stopwatch.Stop();
Console.WriteLine($"PersistedGrantStore.RemoveAllAsync({subject}, {client}, {type}, {sessionTarget}): {stopwatch.ElapsedMilliseconds} ms");
returnGrants = (await store.GetAllAsync(new PersistedGrantFilter()
{
SubjectId = subject, ClientId = client, Type = type
})).ToList();
Assert.AreEqual <int>(grants.Count - 1, returnGrants.Count);
}
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 StoreAsync_WhenPersistedGrantStored_ExpectSuccess()
{
var persistedGrant = CreateTestObject();
var store = new PersistedGrantStore(_context, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
var foundGrant = (await _context.PersistedGrants.WhereEqualTo("Key", persistedGrant.Key).GetSnapshotAsync())[0].ConvertTo <Entities.PersistedGrant>();
Assert.NotNull(foundGrant);
}
public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess()
{
var persistedGrant = CreateTestObject();
var store = new PersistedGrantStore(g.operationalDb, FakeLogger <PersistedGrantStore> .Create());
await store.StoreAsync(persistedGrant);
var foundGrant = g.operationalDb.Select <Storage.Entities.PersistedGrant>().Where(x => x.Key == persistedGrant.Key).First();
Assert.NotNull(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 RemoveAsync_WhenSubIdClientIdAndTypeOfExistingReceived_ExpectGrantDeleted()
{
var store = new PersistedGrantStore(new TestOptions(), new FakeLogger <PersistedGrantStore>());
var persistedGrant = CreateTestObject();
store.StoreAsync(persistedGrant).Wait();
store.RemoveAllAsync(persistedGrant.SubjectId, persistedGrant.ClientId, persistedGrant.Type).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 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 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 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 async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess(DbContextOptions <PersistedGrantDbContext> options)
{
var persistedGrant = CreateTestObject();
using (var context = new PersistedGrantDbContext(options))
{
var store = new PersistedGrantStore(context, FakeLogger <PersistedGrantStore> .Create(), new NoneCancellationTokenProvider());
await store.StoreAsync(persistedGrant);
}
using (var context = new PersistedGrantDbContext(options))
{
var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
Assert.NotNull(foundGrant);
}
}
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 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 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);
}