public async Task StoreUserConsentAsync_should_update_entity()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <UserConsentStore> >();
var UserConsent = new Consent
{
ClientId = "test",
SubjectId = "test"
};
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.UserConsent
{
Id = "test",
ClientId = "test",
UserId = "test",
Data = serializer.Serialize(UserConsent)
}, $"{nameof(Entity.UserConsent)}/test");
await s1.SaveChangesAsync();
using var session = store.OpenAsyncSession();
var sut = new UserConsentStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
await sut.StoreUserConsentAsync(UserConsent);
using var s2 = store.OpenAsyncSession();
var result = await s2.Advanced.LoadStartingWithAsync <Entity.UserConsent>($"{nameof(Entity.UserConsent).ToLowerInvariant()}/");
Assert.Single(result);
}
public async Task CreateAsync_should_return_claim_id()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var roleResult = await roleManager.CreateAsync(role);
Assert.True(roleResult.Succeeded);
var sut = new IdentityRoleClaimStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleClaimStore <IdentityUser, IdentityRole> > >());
var result = await sut.CreateAsync(new RoleClaim
{
ClaimType = "test",
ClaimValue = "test",
RoleId = role.Id
} as object);
Assert.NotNull(result);
Assert.NotNull(((RoleClaim)result).Id);
}
public async Task UdpateAsync_should_update_claim()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var result = await roleManager.CreateAsync(role);
Assert.True(result.Succeeded);
result = await roleManager.AddClaimAsync(role, new Claim("test", "test"));
Assert.True(result.Succeeded);
var sut = new IdentityRoleClaimStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleClaimStore <IdentityUser, IdentityRole> > >());
await sut.UpdateAsync(new RoleClaim
{
Id = $"{role.Id}@0",
ClaimType = Guid.NewGuid().ToString(),
ClaimValue = Guid.NewGuid().ToString()
} as object);
var claims = await roleManager.GetClaimsAsync(role);
Assert.Single(claims);
Assert.NotEqual("test", claims.First().Type);
Assert.NotEqual("test", claims.First().Value);
}
public async Task GetAsync_by_page_request_should_find_role_claims()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var roleResult = await roleManager.CreateAsync(role);
Assert.True(roleResult.Succeeded);
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
var sut = new IdentityRoleClaimStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleClaimStore <IdentityUser, IdentityRole> > >());
var claimsResult = await sut.GetAsync(new PageRequest
{
Filter = $"RoleId eq '{role.Id}'",
Take = 1
});
Assert.NotNull(claimsResult);
Assert.Equal(3, claimsResult.Count);
Assert.Single(claimsResult.Items);
}
public async Task GetAsync_by_id_should_return_claim()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var roleResult = await roleManager.CreateAsync(role);
Assert.True(roleResult.Succeeded);
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
await roleManager.AddClaimAsync(role, new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
var sut = new IdentityRoleClaimStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleClaimStore <IdentityUser, IdentityRole> > >());
var result = await sut.GetAsync($"{role.Id}@1", null);
Assert.NotNull(result);
}
public async Task UdpateAsync_should_update_role()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var result = await roleManager.CreateAsync(role);
Assert.True(result.Succeeded);
var sut = new IdentityRoleStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleStore <IdentityUser, IdentityRole> > >());
await sut.UpdateAsync(new Role
{
Id = role.Id,
Name = "test"
} as object);
var actual = await roleManager.FindByIdAsync(role.Id);
Assert.NotNull(actual);
Assert.Equal("test", actual.Name);
}
public async Task GetAsync_by_id_should_expand_claims()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var provider = new ServiceCollection()
.AddLogging()
.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore)
.Services.BuildServiceProvider();
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var role = new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
var roleResult = await roleManager.CreateAsync(role);
Assert.True(roleResult.Succeeded);
var claimId = Guid.NewGuid().ToString();
await roleManager.AddClaimAsync(role, new Claim(claimId, claimId)).ConfigureAwait(false);
var sut = new IdentityRoleStore <IdentityUser, IdentityRole>(roleManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityRoleStore <IdentityUser, IdentityRole> > >());
var result = await sut.GetAsync(role.Id, new GetRequest
{
Expand = nameof(Role.RoleClaims)
});
Assert.NotNull(result);
Assert.Single(result.RoleClaims);
Assert.Equal(claimId, result.RoleClaims.First().ClaimType);
Assert.Equal($"{role.Id}@0", result.RoleClaims.First().Id);
}
public async Task DeleteAsync_should_delete_user()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var services = new ServiceCollection()
.AddLogging();
services.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore);
IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider();
using var scope = provider.CreateScope();
provider = scope.ServiceProvider;
var userManager = provider.GetRequiredService <UserManager <IdentityUser> >();
var user = new IdentityUser
{
Id = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = Guid.NewGuid().ToString()
};
var result = await userManager.CreateAsync(user);
Assert.True(result.Succeeded);
var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >());
await sut.DeleteAsync(user.Id);
var actual = await userManager.FindByIdAsync(user.Id);
Assert.Null(actual);
}
public async Task CreateAsync_should_throw_when_parents_not_found()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ProtectResource
{
Id = "test"
}, $"{nameof(Entity.ProtectResource).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var loggerMock = new Mock <ILogger <ApiApiScopeStore> >();
using var session = store.OpenAsyncSession();
var sut = new ApiApiScopeStore(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var entity = new Entity.ApiApiScope
{
Id = Guid.NewGuid().ToString(),
ApiId = "unknow",
ApiScopeId = "test"
};
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.CreateAsync(entity));
entity.ApiId = "test";
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.CreateAsync(entity));
}
public async Task FindIdentityResourcesByScopeNameAsync_should_find_identity_by_name()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.IdentityResource
{
Id = "test",
Resources = new List <Entity.IdentityLocalizedResource>
{
new Entity.IdentityLocalizedResource
{
Id = $"{nameof(Entity.IdentityLocalizedResource).ToLowerInvariant()}/test"
}
}
}, $"{nameof(Entity.IdentityResource).ToLowerInvariant()}/test");
await s1.StoreAsync(new Entity.IdentityLocalizedResource
{
Id = "test",
IdentityId = "test",
ResourceKind = Entity.EntityResourceKind.DisplayName,
Value = "test"
}, $"{nameof(Entity.IdentityLocalizedResource).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var sut = new ResourceStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
var result = await sut.FindIdentityResourcesByScopeNameAsync(new[] { "test" });
Assert.NotEmpty(result);
}
public async Task CreateAsync_should_add_entity_id_to_parent()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.RelyingParty
{
Id = "test",
}, $"{nameof(Entity.RelyingParty).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var loggerMock = new Mock <ILogger <AdminStore <Entity.RelyingPartyClaimMapping> > >();
using var session = store.OpenAsyncSession();
var sut = CreateSut(session, loggerMock.Object);
var entity = new Entity.RelyingPartyClaimMapping
{
Id = Guid.NewGuid().ToString(),
RelyingPartyId = "test"
};
await sut.CreateAsync(entity);
using var s2 = store.OpenAsyncSession();
var parent = await s2.LoadAsync <Entity.RelyingParty>($"{nameof(Entity.RelyingParty).ToLowerInvariant()}/test");
var collection = GetCollection(parent);
Assert.Contains(collection, i => i.Id == $"{typeof(Entity.RelyingPartyClaimMapping).Name.ToLowerInvariant()}/{entity.Id}");
}
public async Task IsOriginAllowedAsync_should_check_SanetizedCorsUri()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ClientUri
{
Id = "allowed",
Kind = Entity.UriKinds.Cors | Entity.UriKinds.Redirect,
SanetizedCorsUri = "HTTP://ALLOWED:5000"
}, $"{nameof(Entity.ClientUri)}/allowed");
await s1.StoreAsync(new Entity.ClientUri
{
Id = "notallowed",
Kind = Entity.UriKinds.Redirect,
SanetizedCorsUri = "HTTP://NOTALLOWED:5000"
}, $"{nameof(Entity.ClientUri)}/notallowed");
await s1.SaveChangesAsync();
var sut = new CorsPolicyService(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
Assert.True(await sut.IsOriginAllowedAsync("http://allowed:5000"));
Assert.False(await sut.IsOriginAllowedAsync("http://notallowed:5000"));
}
public async Task UpdateByUserCodeAsync_should_update_device_code()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <DeviceFlowStore> >();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.DeviceCode
{
Id = "test",
UserCode = "code",
Data = serializer.Serialize(new DeviceCode
{
AuthorizedScopes = new[] { "client_credential" }
})
}, $"{nameof(Entity.DeviceCode)}/test");
await s1.SaveChangesAsync();
var sut = new DeviceFlowStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()), serializer, loggerMock.Object);
await sut.UpdateByUserCodeAsync("code", new DeviceCode
{
ClientId = "test"
});
using var s2 = store.OpenAsyncSession();
var updated = await s2.LoadAsync <Entity.DeviceCode>($"{nameof(Entity.DeviceCode)}/test");
var data = serializer.Deserialize <DeviceCode>(updated.Data);
Assert.Equal("test", data.ClientId);
}
public async Task CreateAsync_should_add_entity_id_to_parent()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Culture
{
Id = "test"
}, $"{nameof(Culture).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var loggerMock = new Mock <ILogger <AdminStore <LocalizedResource> > >();
using var session = store.OpenAsyncSession();
var sut = CreateSut(session, loggerMock.Object);
var entity = new LocalizedResource
{
Id = Guid.NewGuid().ToString(),
CultureId = "test"
};
await sut.CreateAsync(entity);
using var s2 = store.OpenAsyncSession();
var parent = await s2.LoadAsync <Culture>($"{nameof(Culture).ToLowerInvariant()}/test");
var collection = GetCollection(parent);
Assert.Contains(collection, i => i.Id == $"{typeof(LocalizedResource).Name.ToLowerInvariant()}/{entity.Id}");
}
public async Task StoreReferenceTokenAsync_should_update_entity()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <ReferenceTokenStore> >();
var token = new Token
{
ClientId = "test"
};
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ReferenceToken
{
Id = "test",
ClientId = "test",
Data = serializer.Serialize(token)
}, $"{nameof(Entity.ReferenceToken)}/test");
await s1.SaveChangesAsync();
using var session = store.OpenAsyncSession();
var sut = new ReferenceTokenStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
var code = await sut.StoreReferenceTokenAsync(token);
Assert.Equal("test", code);
}
public async Task DeleteAsync_should_not_throw_when_parent_not_exists()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var entity = new Entity.RelyingPartyClaimMapping
{
Id = Guid.NewGuid().ToString(),
RelyingPartyId = "test"
};
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(entity, $"{typeof(Entity.RelyingPartyClaimMapping).Name.ToLowerInvariant()}/{entity.Id}");
await s1.SaveChangesAsync();
var loggerMock = new Mock <ILogger <AdminStore <Entity.RelyingPartyClaimMapping> > >();
using var session = store.OpenAsyncSession();
var sut = CreateSut(session, loggerMock.Object);
await sut.DeleteAsync(entity.Id);
using var s2 = store.OpenAsyncSession();
Assert.Null(await s2.LoadAsync <Entity.RelyingPartyClaimMapping>($"{typeof(Entity.RelyingPartyClaimMapping).Name.ToLowerInvariant()}/{entity.Id}"));
}
public async Task FindApiScopesByNameAsync_should_find_apiScope_by_name()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ApiScope
{
Id = "test",
Properties = new List <Entity.ApiScopeProperty>
{
new Entity.ApiScopeProperty
{
Id = $"{nameof(Entity.ApiScopeProperty).ToLowerInvariant()}/test"
}
}
}, $"{nameof(Entity.ApiScope).ToLowerInvariant()}/test");
await s1.StoreAsync(new Entity.ApiScopeProperty
{
Id = "test",
ApiScopeId = "test",
Key = "test",
Value = "test"
}, $"{nameof(Entity.ApiScopeProperty).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var sut = new ResourceStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
var result = await sut.FindApiScopesByNameAsync(new[] { "test" });
Assert.NotEmpty(result);
}
public async Task StoreAuthorizationCodeAsync_should_update_entity()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <AuthorizationCodeStore> >();
var authorizationCode = new AuthorizationCode
{
ClientId = "test",
Subject = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(JwtClaimTypes.Subject, "test") }))
};
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.AuthorizationCode
{
Id = "test",
ClientId = "test",
UserId = "test",
Data = serializer.Serialize(authorizationCode)
}, $"{nameof(Entity.AuthorizationCode)}/test");
await s1.SaveChangesAsync();
using var session = store.OpenAsyncSession();
var sut = new AuthorizationCodeStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
var code = await sut.StoreAuthorizationCodeAsync(authorizationCode);
Assert.Equal("test", code);
}
public async Task CreateAsync_should_create_user()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var services = new ServiceCollection()
.AddLogging();
services.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore);
IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider();
using var scope = provider.CreateScope();
provider = scope.ServiceProvider;
var userManager = provider.GetRequiredService <UserManager <IdentityUser> >();
var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >());
var result = await sut.CreateAsync(new Entity.User
{
Email = "*****@*****.**",
UserName = Guid.NewGuid().ToString()
} as object);
Assert.NotNull(result);
Assert.NotNull(((Entity.User)result).Id);
}
public async Task GetReferenceTokenAsync_should_return_grant_by_hamlder()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <ReferenceTokenStore> >();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ReferenceToken
{
Id = "test",
ClientId = "test",
Data = serializer.Serialize(new Token
{
ClientId = "test"
})
}, $"{nameof(Entity.ReferenceToken)}/test");
await s1.SaveChangesAsync();
using var session = store.OpenAsyncSession();
var sut = new ReferenceTokenStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
var result = await sut.GetReferenceTokenAsync("test");
Assert.NotNull(result);
}
public async Task FindByUserCodeAsync_should_find_device_code_by_user_code()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <DeviceFlowStore> >();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.DeviceCode
{
Id = "test",
UserCode = "code",
Data = serializer.Serialize(new DeviceCode
{
AuthorizedScopes = new[] { "client_credential" }
})
}, $"{nameof(Entity.DeviceCode)}/test");
await s1.SaveChangesAsync();
var sut = new DeviceFlowStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()), serializer, loggerMock.Object);
var result = await sut.FindByUserCodeAsync("code");
Assert.NotNull(result);
}
public async Task FindClientByIdAsync_should_return_client()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.Client
{
Id = "test",
AllowedGrantTypes = new List <Entity.ClientGrantType>
{
new Entity.ClientGrantType
{
Id = $"{nameof(Entity.ClientGrantType).ToLowerInvariant()}/test"
}
}
}, $"{nameof(Entity.Client)}/test");
await s1.StoreAsync(new Entity.ClientGrantType
{
Id = "test",
GrantType = "client_credential"
}, $"{nameof(Entity.ClientGrantType).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var sut = new ClientStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
var result = await sut.FindClientByIdAsync("test");
Assert.NotNull(result);
Assert.Contains(result.AllowedGrantTypes, g => g == "client_credential");
}
public async Task RemoveReferenceTokenAsync_by_subjectId_clientId_should_delete_entity()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <ReferenceTokenStore> >();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.ReferenceToken
{
Id = "test",
ClientId = "test",
UserId = "test",
Data = serializer.Serialize(new Token
{
ClientId = "test"
})
}, $"{nameof(Entity.ReferenceToken)}/test");
await s1.SaveChangesAsync();
using var session = store.OpenAsyncSession();
var sut = new ReferenceTokenStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
await sut.RemoveReferenceTokensAsync("test", "test");
using var s2 = store.OpenAsyncSession();
var result = await s2.LoadAsync <Entity.ReferenceToken>($"{nameof(Entity.ReferenceToken)}/test");
Assert.Null(result);
}
public async Task DeleteAsync_should_remove_entity_id_from_parents()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var entity = new Entity.ApiApiScope
{
Id = Guid.NewGuid().ToString(),
ApiId = "test",
ApiScopeId = "test"
};
var api = new Entity.ProtectResource
{
Id = "test",
ApiScopes = new List <Entity.ApiApiScope>
{
new Entity.ApiApiScope
{
Id = $"{typeof(Entity.ApiApiScope).Name.ToLowerInvariant()}/{entity.Id}"
}
}
};
var apiScope = new Entity.ApiScope
{
Id = "test",
Apis = new List <Entity.ApiApiScope>
{
new Entity.ApiApiScope
{
Id = $"{typeof(Entity.ApiApiScope).Name.ToLowerInvariant()}/{entity.Id}"
}
}
};
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(api, $"{nameof(Entity.ProtectResource).ToLowerInvariant()}/{api.Id}");
await s1.StoreAsync(apiScope, $"{nameof(Entity.ApiScope).ToLowerInvariant()}/{apiScope.Id}");
await s1.StoreAsync(entity, $"{typeof(Entity.ApiApiScope).Name.ToLowerInvariant()}/{entity.Id}");
await s1.SaveChangesAsync();
var loggerMock = new Mock <ILogger <AdminStore <Entity.ApiApiScope> > >();
using var session = store.OpenAsyncSession();
var sut = new ApiApiScopeStore(new ScopedAsynDocumentcSession(session), loggerMock.Object);
await sut.DeleteAsync(entity.Id);
using var s2 = store.OpenAsyncSession();
var apiUpdated = await s2.LoadAsync <Entity.ProtectResource>($"{nameof(Entity.ProtectResource).ToLowerInvariant()}/test");
Assert.DoesNotContain(apiUpdated.ApiScopes, i => i.Id == $"{typeof(Entity.ApiApiScope).Name.ToLowerInvariant()}/{entity.Id}");
var apiScopeUpdated = await s2.LoadAsync <Entity.ApiScope>($"{nameof(Entity.ApiScope).ToLowerInvariant()}/test");
Assert.DoesNotContain(apiScopeUpdated.Apis, i => i.Id == $"{typeof(Entity.ApiApiScope).Name.ToLowerInvariant()}/{entity.Id}");
}
public async Task GetAsync_by_odata_requqest_should_expand_properties()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
var resourceId = Guid.NewGuid().ToString();
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true,
Resources = new List <ApiLocalizedResource>
{
new ApiLocalizedResource
{
Id = $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{resourceId}"
}
}
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.StoreAsync(new ApiLocalizedResource
{
Id = resourceId,
ApiId = $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{id}",
CultureId = "fr",
ResourceKind = EntityResourceKind.DisplayName,
Value = "test"
}, $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{resourceId}");
await s1.SaveChangesAsync();
}
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var page = await sut.GetAsync(new PageRequest
{
Expand = "Resources"
});
Assert.Single(page.Items);
Assert.NotNull(page.Items.First().Resources);
Assert.Single(page.Items.First().Resources);
Assert.Equal(resourceId, page.Items.First().Resources.First().Id);
Assert.Equal(id, page.Items.First().Resources.First().ApiId);
Assert.Equal("fr", page.Items.First().Resources.First().CultureId);
Assert.Equal("test", page.Items.First().Resources.First().Value);
}
public async Task UpdateByUserCodeAsync_should_throw_when_handle_not_found()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <RefreshTokenStore> >();
var sut = new RefreshTokenStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()), serializer, loggerMock.Object);
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.UpdateRefreshTokenAsync("handle", new RefreshToken()));
}
public async Task FindByUserCodeAsync_should_throw_when_code_is_null()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <DeviceFlowStore> >();
var sut = new DeviceFlowStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()), serializer, loggerMock.Object);
await Assert.ThrowsAsync <ArgumentNullException>(() => sut.FindByUserCodeAsync(null));
}
public async Task StoreAuthorizationCodeAsync_should_throw_when_subject_is_null()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var serializer = new PersistentGrantSerializer();
var loggerMock = new Mock <ILogger <AuthorizationCodeStore> >();
using var session = store.OpenAsyncSession();
var sut = new AuthorizationCodeStore(new ScopedAsynDocumentcSession(session), serializer, loggerMock.Object);
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.StoreAuthorizationCodeAsync(new AuthorizationCode()));
}
public async Task GetAsync_by_id_should_expand_claims_and_roles()
{
using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore();
var services = new ServiceCollection()
.AddLogging();
services.AddIdentity <IdentityUser, IdentityRole>()
.AddRavenDbStores(p => documentStore);
IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider();
using var scope = provider.CreateScope();
provider = scope.ServiceProvider;
var userManager = provider.GetRequiredService <UserManager <IdentityUser> >();
var user = new IdentityUser
{
Id = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = Guid.NewGuid().ToString()
};
var userResult = await userManager.CreateAsync(user);
Assert.True(userResult.Succeeded);
await userManager.AddClaimsAsync(user, new[]
{
new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString())
}).ConfigureAwait(false);
var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >();
var roleName = Guid.NewGuid().ToString();
await roleManager.CreateAsync(new IdentityRole
{
Id = Guid.NewGuid().ToString(),
Name = roleName
}).ConfigureAwait(false);
await userManager.AddToRoleAsync(user, roleName).ConfigureAwait(false);
var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >());
var result = await sut.GetAsync(user.Id, new GetRequest
{
Expand = $"{nameof(Entity.User.UserClaims)},{nameof(Entity.User.UserRoles)}"
});
Assert.NotNull(result);
Assert.Single(result.UserClaims);
Assert.Single(result.UserRoles);
}
public async Task GetAsync_should_filter_by_odata_request()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.SaveChangesAsync();
}
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.Id)} eq 'test'",
Skip = 0,
Take = 10
});
Assert.Single(page.Items);
page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.DisplayName)} eq 'no-test'",
Skip = 0,
Take = 10
});
Assert.Empty(page.Items);
page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.CreatedAt)} eq {DateTime.UtcNow.ToString("o")}",
Skip = 0,
Take = 10
});
Assert.Empty(page.Items);
}
