public async Task DeleteClientSecretAsync()
{
IClientRepository clientRepository = new ClientDapperRepository(_configuration);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient();
//Add new client
var clientId = await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(clientId);
//Assert new client
clientEntity.ShouldBeEquivalentTo(client, options => options.Excluding(o => o.Id)
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedGrantTypes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "RedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "PostLogoutRedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedScopes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "IdentityProviderRestrictions\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedCorsOrigins\\[.+\\].Id")));
//Generate random new Client Secret
var clientSecret = ClientMock.GenerateRandomClientSecret();
//Add new client secret
var clientSecretId = await clientRepository.AddClientSecretAsync(clientEntity.Id, clientSecret);
//Get new client secret
var newSecret = await clientRepository.GetClientSecretAsync(clientSecretId);
//Asert
newSecret.ShouldBeEquivalentTo(clientSecret, options => options.Excluding(o => o.Id).Excluding(x => x.Client).Excluding(x => x.Expiration));
//Try delete it
await clientRepository.DeleteClientSecretAsync(newSecret);
//Get new client secret
var deletedSecret = await clientRepository.GetClientSecretAsync(clientSecret.Id);
//Assert
deletedSecret.Should().BeNull();
}
public async Task DeleteClientPropertyAsync()
{
using (var context = new IdentityServerConfigurationDbContext(_dbContextOptions, _storeOptions))
{
var clientRepository = GetClientRepository(context);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient(0);
//Add new client
await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(client.Id);
//Assert new client
ClientAssert(clientEntity, client);
//Generate random new Client Property
var clientProperty = ClientMock.GenerateRandomClientProperty(0);
//Add new client property
await clientRepository.AddClientPropertyAsync(clientEntity.Id, clientProperty);
//Get new client property
var newClientProperties = await context.ClientProperties.Where(x => x.Id == clientProperty.Id)
.SingleOrDefaultAsync();
//Assert
newClientProperties.Should().BeEquivalentTo(clientProperty,
options => options.Excluding(o => o.Id).Excluding(x => x.Client));
//Try delete it
await clientRepository.DeleteClientPropertyAsync(newClientProperties);
//Get new client property
var deletedClientProperty = await context.ClientProperties.Where(x => x.Id == clientProperty.Id)
.SingleOrDefaultAsync();
//Assert
deletedClientProperty.Should().BeNull();
}
}
public async Task GetClientAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
IClientRepository clientRepository = new ClientRepository(context);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient(0);
//Add new client
await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(client.Id);
//Assert new client
clientEntity.ShouldBeEquivalentTo(client, options => options.Excluding(o => o.Id));
}
}
public void TriggersOnChanged()
{
var subscriber = new Subscriber <ConfigDirectoriesChanged>(Fixture.WurmApiManager.InternalEventAggregator);
var batman = ClientMock.AddConfig("batmobile");
subscriber.WaitMessages(1);
// verifying event sent
Expect(subscriber.ReceivedMessages.Count(), GreaterThan(0));
// verifying data updated
var allConfigs = System.AllConfigNames.ToList();
var allDirFullPaths = System.AllDirectoriesFullPaths.ToList();
var allDirNames = System.AllDirectoryNamesNormalized.ToList();
Expect(allConfigs, Member(batman.NameNormalized).And.Count.EqualTo(1));
Expect(allDirFullPaths, Member(batman.ConfigDir.FullName).And.Count.EqualTo(1));
Expect(allDirNames, Member(batman.ConfigDir.Name.ToUpperInvariant()).And.Count.EqualTo(1));
}
public async Task GetClientAsync()
{
using (var context = new IdentityServerConfigurationDbContext(_dbContextOptions, _storeOptions))
{
var clientRepository = GetClientRepository(context);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient(0);
//Add new client
await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(client.Id);
//Assert new client
ClientAssert(clientEntity, client);
}
}
public async Task AddClientAsync()
{
using (var context = new IdentityServerConfigurationDbContext(_dbContextOptions, _storeOptions))
{
var clientRepository = GetClientRepository(context);
//Generate random new client
var client = ClientMock.GenerateRandomClient(0);
//Add new client
await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await context.Clients.Where(x => x.Id == client.Id).SingleAsync();
//Assert new client
clientEntity.ShouldBeEquivalentTo(client, options => options.Excluding(o => o.Id));
}
}
public async Task DeleteClientClaimAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
IClientRepository clientRepository = new ClientRepository(context);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient(0);
//Add new client
await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(client.Id);
//Assert new client
clientEntity.ShouldBeEquivalentTo(client, options => options.Excluding(o => o.Id));
//Generate random new Client Claim
var clientClaim = ClientMock.GenerateRandomClientClaim(0);
//Add new client claim
await clientRepository.AddClientClaimAsync(clientEntity.Id, clientClaim);
//Get new client claim
var newClientClaim =
await context.ClientClaims.Where(x => x.Id == clientClaim.Id).SingleOrDefaultAsync();
//Asert
newClientClaim.ShouldBeEquivalentTo(clientClaim,
options => options.Excluding(o => o.Id).Excluding(x => x.Client));
//Try delete it
await clientRepository.DeleteClientClaimAsync(newClientClaim);
//Get new client claim
var deletedClientClaim =
await context.ClientClaims.Where(x => x.Id == clientClaim.Id).SingleOrDefaultAsync();
//Assert
deletedClientClaim.Should().BeNull();
}
}
public void CanMapClientToModel()
{
//Generate entity
var client = ClientMock.GenerateRandomClient(0);
//Try map to DTO
var clientDto = client.ToModel();
//Asert
clientDto.Should().NotBeNull();
client.Should().BeEquivalentTo(clientDto, options =>
options.Excluding(o => o.AccessTokenTypes)
.Excluding(o => o.Created)
.Excluding(o => o.AllowedCorsOrigins)
.Excluding(o => o.AllowedCorsOriginsItems)
.Excluding(o => o.AllowedGrantTypes)
.Excluding(o => o.AllowedGrantTypesItems)
.Excluding(o => o.AllowedScopes)
.Excluding(o => o.AllowedScopesItems)
.Excluding(o => o.Claims)
.Excluding(o => o.ClientSecrets)
.Excluding(o => o.ClientType)
.Excluding(o => o.Properties)
.Excluding(o => o.ProtocolTypes)
.Excluding(o => o.PostLogoutRedirectUris)
.Excluding(o => o.PostLogoutRedirectUrisItems)
.Excluding(o => o.RedirectUris)
.Excluding(o => o.RedirectUrisItems)
.Excluding(o => o.RefreshTokenUsages)
.Excluding(o => o.RefreshTokenExpirations)
.Excluding(o => o.IdentityProviderRestrictions)
.Excluding(o => o.IdentityProviderRestrictionsItems));
//Assert collection
client.AllowedCorsOrigins.Select(x => x.Origin).Should().BeEquivalentTo(clientDto.AllowedCorsOrigins);
client.RedirectUris.Select(x => x.RedirectUri).Should().BeEquivalentTo(clientDto.RedirectUris);
client.PostLogoutRedirectUris.Select(x => x.PostLogoutRedirectUri).Should().BeEquivalentTo(clientDto.PostLogoutRedirectUris);
client.AllowedGrantTypes.Select(x => x.GrantType).Should().BeEquivalentTo(clientDto.AllowedGrantTypes);
client.AllowedScopes.Select(x => x.Scope).Should().BeEquivalentTo(clientDto.AllowedScopes);
client.IdentityProviderRestrictions.Select(x => x.Provider).Should().BeEquivalentTo(clientDto.IdentityProviderRestrictions);
}
public async Task GetClientsAsync()
{
IClientRepository clientRepository = new ClientDapperRepository(_configuration);
var rnd = new Random();
var generateRows = rnd.Next(1, 10);
//Generate random new clients
var randomClients = ClientMock.GenerateRandomClients(0, generateRows);
foreach (var client in randomClients)
{
await clientRepository.AddClientAsync(client);
}
var clients = await clientRepository.GetClientsAsync();
//Assert clients count
clients.Data.Count.Should().BeGreaterThan(randomClients.Count);
}
public void CanMapClientSecretToModel()
{
var clientSecret = ClientMock.GenerateRandomClientSecret(0);
var clientSecretsDto = clientSecret.ToModel();
//Assert
clientSecretsDto.Should().NotBeNull();
clientSecret.Should().BeEquivalentTo(clientSecretsDto, options =>
options.Excluding(o => o.ClientSecretId)
.Excluding(o => o.ClientSecrets)
.Excluding(o => o.ClientName)
.Excluding(o => o.PageSize)
.Excluding(o => o.TotalCount)
.Excluding(o => o.HashType)
.Excluding(o => o.HashTypes)
.Excluding(o => o.HashTypeEnum)
.Excluding(o => o.TypeList)
.Excluding(o => o.ClientId));
}
public async Task UpdateClientAsync()
{
IClientRepository clientRepository = new ClientDapperRepository(_configuration);
//Generate random new client without id
var client = ClientMock.GenerateRandomClient();
//Add new client
var clientId = await clientRepository.AddClientAsync(client);
//Get new client
var clientEntity = await clientRepository.GetClientAsync(clientId);
//Assert new client
clientEntity.ShouldBeEquivalentTo(client, options => options.Excluding(o => o.Id)
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedGrantTypes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "RedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "PostLogoutRedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedScopes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "IdentityProviderRestrictions\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedCorsOrigins\\[.+\\].Id")));
//Generete new client with added item id
var updatedClient = ClientMock.GenerateRandomClient(clientEntity.Id);
//Update client
await clientRepository.UpdateClientAsync(updatedClient);
//Get updated client
var updatedClientEntity = await clientRepository.GetClientAsync(updatedClient.Id);
//Assert updated client
updatedClientEntity.ShouldBeEquivalentTo(updatedClient, options => options.Excluding(o => o.Id)
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedGrantTypes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "RedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "PostLogoutRedirectUris\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedScopes\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "IdentityProviderRestrictions\\[.+\\].Id"))
.Excluding(x => Regex.IsMatch(x.SelectedMemberPath, "AllowedCorsOrigins\\[.+\\].Id")));
}
public async Task ConfigureMongoDbIndexesService_Executes_Task()
{
var target = CreateTarget();
var task = target.StartAsync(CancellationToken.None);
await task;
await Task.Delay(1000);
Assert.IsTrue(task.IsCompleted);
await target.StopAsync(CancellationToken.None);
VerifyInformationWasLogged(LoggerMock);
ClientMock.Verify(s => s.GetDatabase(It.IsAny <string>(), null), Times.Once);
DatabaseMock.Verify(
s => s.GetCollection <User>(nameof(User), null), Times.Once);
CollectionMock.VerifyGet(s => s.Indexes, Times.Once);
IndexManagerMock.Verify(
s => s.CreateOneAsync(It.IsAny <CreateIndexModel <User> >(), null, CancellationToken.None),
Times.Once);
}
public async Task CloneClientWithoutScopesAsync()
{
//Generate random new client
var client = ClientMock.GenerateRandomClient(0, generateClaims: true, generateProperties: true, generateSecrets: true);
IClientRepository clientRepository = new ClientDapperRepository(_configuration);
//Add new client
var clientId = await clientRepository.AddClientAsync(client);
var clientToClone = await clientRepository.GetClientAsync(clientId);
clientToClone.ClientId = $"{clientToClone.ClientId}(Clone))";
//Try clone it
var clonedClientId = await clientRepository.CloneClientAsync(clientToClone, cloneClientScopes : false);
var cloneClientEntity = await clientRepository.GetClientAsync(clonedClientId);
var clientToCompare = await clientRepository.GetClientAsync(clientToClone.Id);
ClientCloneCompare(cloneClientEntity, clientToCompare, cloneClientScopes: false);
}
public async Task ShouldReturnObjectIfCreateSucceeds()
{
var type = "TypTvå";
var clientMock = new ClientMock(_pact)
{
ConditionDescription = $"Creating new product",
Response = new ProviderServiceResponse {
Status = 201,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new ProductDto {
Id = 10,
Time = new DateTime(1984, 01, 01),
Type = type
}
}
};
var repo = new PactConsumer1.ProducerRepository(clientMock);
var product = await repo.CreateProductOfType(type);
Assert.NotNull(product);
Assert.Equal(type, product.Type);
}
public async Task CloneClientWithoutScopesAsync()
{
using (var context = new IdentityServerConfigurationDbContext(_dbContextOptions, _storeOptions))
{
//Generate random new client
var client = ClientMock.GenerateRandomClient(0, generateClaims: true, generateProperties: true, generateSecrets: false);
var clientRepository = GetClientRepository(context);
//Add new client
await clientRepository.AddClientAsync(client);
var clientToClone = await context.Clients.Where(x => x.Id == client.Id).SingleOrDefaultAsync();
//Try clone it
var clonedClientId = await clientRepository.CloneClientAsync(clientToClone, cloneClientScopes : false);
var cloneClientEntity = await clientRepository.GetClientAsync(clonedClientId);
var clientToCompare = await clientRepository.GetClientAsync(clientToClone.Id);
ClientCloneCompare(cloneClientEntity, clientToCompare, cloneClientScopes: false);
}
}
public void TestOperationalEventIsNotFiredIfAMessageIsNotFired()
{
Twin.ChangeEventPriority(typeof(FakeOperationalEvent).Name, EventPriority.Operational)
.ChangeEventPriority(typeof(FakePeriodicEvent).Name, EventPriority.Off)
.ChangeEventPriority(typeof(FakeTriggeredEvent).Name, EventPriority.Off)
.UpdateAgentTwinConfiguration();
var expectedOperationalEvent = FakesEventsFactory.CreateFakeOperationalEvent();
var expectedPeriodicEvent = FakesEventsFactory.CreateFakePeriodicEvent(EventPriority.High);
var expectedTriggeredEvent = FakesEventsFactory.CreateFakeTriggeredEvent(EventPriority.Low);
FakeOperationalEventGenerator.SetEvents(new[] { expectedOperationalEvent });
FakeSnapshotEventGenerator.SetEvents(new[] { expectedPeriodicEvent });
FakeTriggeredEventGenerator.SetEvents(new[] { expectedTriggeredEvent });
_eventProducer.ExecuteTask();
_eventProducer.ExecuteTask();
_messageBuilderConsumer.ExecuteTask();
var sentMessages = ClientMock.GetMessages();
Assert.AreEqual(0, sentMessages.Count);
}
public async Task ShouldReturnProductIfExists()
{
var id = 1;
var clientMock = new ClientMock(_pact)
{
ConditionDescription = $"Subject with id '{id}' exists",
Response = new ProviderServiceResponse {
Status = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new ProductDto {
Id = id,
Time = new DateTime(1984, 01, 01),
Type = "TypEtt"
}
}
};
var repo = new PactConsumer1.ProducerRepository(clientMock);
var product = await repo.GetProductById(id);
Assert.NotNull(product);
Assert.Equal(id, product.Id);
}
public async Task CloneClientAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
//Generate random new client
var client = ClientMock.GenerateRandomClient(0, generateClaims: true, generateProperties: true, generateSecrets: true);
IClientRepository clientRepository = new ClientRepository(context);
//Add new client
await clientRepository.AddClientAsync(client);
var clientToClone = await context.Clients.Where(x => x.Id == client.Id).SingleOrDefaultAsync();
//Try clone it - all client collections without secrets
var clonedClientId = await clientRepository.CloneClientAsync(clientToClone);
var cloneClientEntity = await clientRepository.GetClientAsync(clonedClientId);
var clientToCompare = await clientRepository.GetClientAsync(clientToClone.Id);
ClientCloneCompare(cloneClientEntity, clientToCompare);
}
}
public void AsyncClientInvokesCorrectClientFunction()
{
ClientMock.Verify(m => m.Get(It.IsAny <IEnumerable <RiakObjectId> >(), 2), Times.Once());
}
public void SetUp()
{
ClientMock.Setup(m => m.Get(It.IsAny <IEnumerable <RiakObjectId> >(), 2)).Returns(new List <RiakResult <RiakObject> >());
Result = AsyncClient.Get(new List <RiakObjectId>(), 2).Result;
}
public void ClientDisconnectedFromServer(ClientMock client)
{
connectedClients.Remove(client);
}
public void ClientConnectedToServer(ClientMock client)
{
connectedClients.Add(client);
}
public void SetUp()
{
ClientMock.Setup(m => m.Get(It.IsAny <string>(), It.IsAny <string>(), 2)).Returns(RiakResult <RiakObject> .Success(new RiakObject("foo", "bar", "baz")));
AsyncClient.Get(new RiakObjectId("foo", "bar"), Tester.HandleResult);
Result = Tester.Result;
}
public void AsyncClientInvokesCorrectClientFunction()
{
ClientMock.Verify(m => m.Get(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <uint>()), Times.Once());
}
private void CreateNewCharacterEmptyDir(string characterName)
{
ClientMock.AddPlayer(characterName);
}
private void CreateNewCharacterDirWithALog(string characterName, string logFileName)
{
var player = ClientMock.AddPlayer(characterName);
player.Logs.CreateCustomLogFile(logFileName);
}
public void Setup()
{
ClientMock.PopulateFromZip(Path.Combine(TestPaksZippedDirFullPath, "logs-samples-realdata.7z"));
}
public void SetUp()
{
ClientMock.Setup(m => m.Ping()).Returns(RiakResult.Success());
Result = AsyncClient.Ping().Result;
}
public void AsyncClientInvokesCorrectClientFunction()
{
ClientMock.Verify(m => m.Ping(), Times.Once());
}
string[] SetupDefaultPlayers()
{
ClientMock.AddPlayer("Foo");
ClientMock.AddPlayer("Bar");
return(new string[] { "Foo", "Bar" });
}
public void SetUp()
{
ClientMock.Setup(m => m.Get(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <uint>())).Returns(RiakResult <RiakObject> .Success(new RiakObject("foo", "bar", "baz")));
Result = AsyncClient.Get("foo", "bar").Result;
}
public void SetUp()
{
ClientMock.Setup(m => m.Ping()).Returns(RiakResult.Success());
AsyncClient.Ping(Tester.HandleResult);
Result = Tester.Result;
}
