public async Task FindApiResourcesByNameAsync_WhenResourcesExist_ExpectOnlyResourcesRequestedReturned()
{
using var ravenStore = GetDocumentStore();
await new ApiResourceIndex().ExecuteAsync(ravenStore);
var resource = CreateApiResourceTestResource();
using (var session = ravenStore.OpenSession())
{
session.Store(resource.ToEntity());
session.Store(CreateApiResourceTestResource().ToEntity());
session.SaveChanges();
}
WaitForIndexing(ravenStore);
ApiResource foundResource;
using (var session = ravenStore.OpenAsyncSession())
{
var store = new ResourceStore(session, FakeLogger <ResourceStore> .Create());
foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
}
Assert.NotNull(foundResource);
Assert.True(foundResource.Name == resource.Name);
Assert.NotNull(foundResource.UserClaims);
Assert.NotEmpty(foundResource.UserClaims);
Assert.NotNull(foundResource.ApiSecrets);
Assert.NotEmpty(foundResource.ApiSecrets);
Assert.NotNull(foundResource.Scopes);
Assert.NotEmpty(foundResource.Scopes);
}
public async Task FindApiResourcesByNameAsync_WhenResourceExists_ExpectResourceAndCollectionsReturned(DbContextOptions <ConfigurationDbContext> options)
{
var resource = CreateApiResourceTestResource();
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
context.ApiResources.Add(resource.ToEntity());
context.SaveChanges();
}
ApiResource foundResource;
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
var store = new ResourceStore(context, FakeLogger <ResourceStore> .Create());
foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
}
Assert.NotNull(foundResource);
Assert.True(foundResource.Name == resource.Name);
Assert.NotNull(foundResource.UserClaims);
Assert.NotEmpty(foundResource.UserClaims);
Assert.NotNull(foundResource.ApiSecrets);
Assert.NotEmpty(foundResource.ApiSecrets);
Assert.NotNull(foundResource.Scopes);
Assert.NotEmpty(foundResource.Scopes);
}
public async Task FindApiResourcesByNameAsync_should_find_api_by_name()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ProtectResource
{
Id = "test",
ApiClaims = new List <Entity.ApiClaim>
{
new Entity.ApiClaim
{
Id = $"{nameof(Entity.ApiClaim).ToLowerInvariant()}/test"
}
}
}, $"{nameof(Entity.ProtectResource).ToLowerInvariant()}/test");
await s1.StoreAsync(new Entity.ApiClaim
{
Id = "test",
ApiId = "test",
Type = "test"
}, $"{nameof(Entity.ApiClaim).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var sut = new ResourceStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
var result = await sut.FindApiResourcesByNameAsync(new[] { "test" });
Assert.NotEmpty(result);
}
public async Task FindApiResourcesByNameAsync_WhenResourcesExist_ExpectOnlyResourcesRequestedReturned()
{
var storeHolder = GetConfigurationDocumentStoreHolder();
var resource = CreateApiResourceTestResource();
using (var session = storeHolder.OpenAsyncSession())
{
await session.StoreAsync(resource.ToEntity());
await session.StoreAsync(CreateApiResourceTestResource().ToEntity());
await session.SaveChangesAsync();
}
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var store = new ResourceStore(storeHolder, FakeLogger <ResourceStore> .Create());
var foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
Assert.NotNull(foundResource);
Assert.True(foundResource.Name == resource.Name);
Assert.NotNull(foundResource.UserClaims);
Assert.NotEmpty(foundResource.UserClaims);
Assert.NotNull(foundResource.ApiSecrets);
Assert.NotEmpty(foundResource.ApiSecrets);
Assert.NotNull(foundResource.Scopes);
Assert.NotEmpty(foundResource.Scopes);
}
public async Task FindApiResourcesByNameAsync_WhenResourcesExist_ExpectOnlyResourcesRequestedReturned()
{
var resource = CreateApiResourceTestResource();
var repo = g.configurationDb.GetRepository <Storage.Entities.ApiResource>();
var entity1 = resource.ToEntity();
repo.Insert(entity1);
repo.SaveMany(entity1, "UserClaims");
repo.SaveMany(entity1, "Scopes");
repo.SaveMany(entity1, "Secrets");
repo.SaveMany(entity1, "Properties");
var entity2 = CreateApiResourceTestResource().ToEntity();
repo.Insert(entity2);
repo.SaveMany(entity2, "UserClaims");
repo.SaveMany(entity2, "Scopes");
repo.SaveMany(entity2, "Secrets");
repo.SaveMany(entity2, "Properties");
ApiResource foundResource;
var store = new ResourceStore(g.configurationDb, FakeLogger <ResourceStore> .Create());
foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
Assert.NotNull(foundResource);
Assert.True(foundResource.Name == resource.Name);
Assert.NotNull(foundResource.UserClaims);
Assert.NotEmpty(foundResource.UserClaims);
Assert.NotNull(foundResource.ApiSecrets);
Assert.NotEmpty(foundResource.ApiSecrets);
Assert.NotNull(foundResource.Scopes);
Assert.NotEmpty(foundResource.Scopes);
}
public async Task Should_Retrieve_Requested_Api_Resource_By_Name(TestDatabase testDb)
{
var testApiResource1 = CreateTestApiResource("test_api_resource5", new[] { "ar5_user_scope1" });
var testApiResource2 = CreateTestApiResource("test_api_resource6", new[] { "ar6_user_scope1" });
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testApiResource1.ToEntity());
await session.SaveAsync(testApiResource2.ToEntity());
await session.FlushAsync();
}
var loggerMock = new Mock <ILogger <ResourceStore> >();
IEnumerable <ApiResource> resources;
using (var session = testDb.OpenStatelessSession())
{
var store = new ResourceStore(session, loggerMock.Object);
resources = (await store.FindApiResourcesByNameAsync(new[] { testApiResource1.Name })).ToList();
}
resources.Count().Should().Be(1);
resources.First().Name.Should().Be("test_api_resource5");
await CleanupTestDataAsync(testDb);
}
public async Task Should_Retrieve_Existing_Api_Resource_By_Name(TestDatabase testDb)
{
var testApiResource = CreateTestApiResource("test_api_resource4", new[] { "ar4_user_claim1" });
var testApiScope = CreateTestApiScopeForResource("ar4_scope", new[] { "ar4scope_user_claim" });
testApiResource.Scopes.Add(testApiScope.Name);
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testApiResource.ToEntity());
await session.SaveAsync(testApiScope.ToEntity());
await session.FlushAsync();
}
var loggerMock = new Mock <ILogger <ResourceStore> >();
ApiResource resource;
using (var session = testDb.OpenStatelessSession())
{
var store = new ResourceStore(session, loggerMock.Object);
resource = (await store.FindApiResourcesByNameAsync(new[] { testApiResource.Name })).SingleOrDefault();
}
resource.Should().NotBeNull();
resource?.Name.Should().Be("test_api_resource4");
resource?.ApiSecrets.Should().NotBeEmpty();
resource?.Scopes.Should().NotBeEmpty();
resource?.Scopes.Count.Should().Be(1);
await CleanupTestDataAsync(testDb);
}
public async Task ResourceStore_Api_SaveGetTest()
{
Stopwatch stopwatch = new Stopwatch();
var storageContext = Services.BuildServiceProvider().GetService <ResourceStorageContext>();
Assert.IsNotNull(storageContext);
var store = new ResourceStore(storageContext, _logger);
Assert.IsNotNull(store);
var resource = CreateApiTestObject();
Console.WriteLine(JsonConvert.SerializeObject(resource));
stopwatch.Start();
await store.StoreAsync(resource);
stopwatch.Stop();
Console.WriteLine($"ResourceStore.StoreAsync({resource.Name})-api: {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Reset();
stopwatch.Start();
var findResource = (await store.FindApiResourcesByNameAsync(new string[] { resource.Name })).FirstOrDefault();
stopwatch.Stop();
Console.WriteLine($"{nameof(ResourceStore.FindApiResourcesByNameAsync)}({resource.Name})-api: {stopwatch.ElapsedMilliseconds} ms");
Assert.AreEqual <string>(resource.Name, findResource.Name);
stopwatch.Reset();
stopwatch.Start();
string[] findScopes = new string[] { "api1Scope", Guid.NewGuid().ToString() };
var findScopesResources = await store.FindApiResourcesByScopeNameAsync(findScopes);
stopwatch.Stop();
Console.WriteLine($"ResourceStore.FindApiResourcesByScopeAsync({string.Join(",", findScopes)})-api: {stopwatch.ElapsedMilliseconds} ms");
Assert.AreEqual <string>(resource.Name, findScopesResources.Single()?.Name);
stopwatch.Reset();
stopwatch.Start();
var resources = await store.GetAllResourcesAsync();
int count = resources.ApiResources.Count();
stopwatch.Stop();
Console.WriteLine($"ResourceStore.GetAllResourcesAsync().ApiResources.Count: {count} : {stopwatch.ElapsedMilliseconds} ms");
Assert.IsTrue(count > 0);
stopwatch.Reset();
stopwatch.Start();
string findScope = findScopes[0];
var apiScopes = await store.FindApiScopesByNameAsync(findScopes);
stopwatch.Stop();
Console.WriteLine($"ResourceStore.FindApiScopesByNameAsync({findScope})-api: {stopwatch.ElapsedMilliseconds} ms");
Assert.AreEqual <int>(1, apiScopes.Where(w => w.Name == findScope).Count());
}
public async Task Should_Not_Retrieve_Non_Existing_Api_Resource(TestDatabase testDb)
{
var loggerMock = new Mock <ILogger <ResourceStore> >();
ApiResource resource;
using (var session = testDb.OpenStatelessSession())
{
var store = new ResourceStore(session, loggerMock.Object);
resource = (await store.FindApiResourcesByNameAsync(new [] { "non_existing_api_resource" })).SingleOrDefault();
}
resource.Should().BeNull();
}
public async Task ResourceStore_Api_RemoveGetTest()
{
Stopwatch stopwatch = new Stopwatch();
var storageContext = Services.BuildServiceProvider().GetService <ResourceStorageContext>();
Assert.IsNotNull(storageContext);
var store = new ResourceStore(storageContext, _logger);
Assert.IsNotNull(store);
string name = Guid.NewGuid().ToString("n");
var resource = CreateApiTestObject(name);
Console.WriteLine(JsonConvert.SerializeObject(resource));
stopwatch.Start();
await store.StoreAsync(resource);
stopwatch.Stop();
Console.WriteLine($"ResourceStore.StoreAsync({resource.Name})-api: {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Reset();
stopwatch.Start();
var resources = await store.GetAllResourcesAsync();
int count = resources.ApiResources.Count();
stopwatch.Stop();
Console.WriteLine($"ResourceStore.GetAllResourcesAsync().ApiResources.Count: {count} : {stopwatch.ElapsedMilliseconds} ms");
Assert.IsNotNull(resources.ApiResources.FirstOrDefault(f => f.Name == name));
//Remove
stopwatch.Reset();
stopwatch.Start();
await store.RemoveApiResourceAsync(resource.Name);
stopwatch.Stop();
Console.WriteLine($"ResourceStore.StoreAsync({resource.Name})-api: {stopwatch.ElapsedMilliseconds} ms");
stopwatch.Reset();
stopwatch.Start();
var findResource = (await store.FindApiResourcesByNameAsync(new string[] { resource.Name })).FirstOrDefault();
stopwatch.Stop();
Console.WriteLine($"ResourceStore.FindResourceByIdAsync({resource.Name})-api: {stopwatch.ElapsedMilliseconds} ms");
Assert.IsNull(findResource);
}
public async Task FindApiResourcesByNameAsync_WhenResourceExists_ExpectResourceAndCollectionsReturned()
{
var resource = CreateApiResourceTestResource();
await _context.ApiResources.AddAsync(resource.ToEntity());
ApiResource foundResource;
var store = new ResourceStore(_context, FakeLogger <ResourceStore> .Create());
foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
Assert.NotNull(foundResource);
Assert.True(foundResource.Name == resource.Name);
Assert.NotNull(foundResource.UserClaims);
Assert.NotEmpty(foundResource.UserClaims);
Assert.NotNull(foundResource.ApiSecrets);
Assert.NotEmpty(foundResource.ApiSecrets);
Assert.NotNull(foundResource.Scopes);
Assert.NotEmpty(foundResource.Scopes);
}
