Example #1
0
        public async Task AddClientPropertyAsync()
        {
            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 property
            var clientProperty = ClientMock.GenerateRandomClientProperty();

            //Add new client property
            var clientPropertyId = await clientRepository.AddClientPropertyAsync(clientEntity.Id, clientProperty);

            //Get new client property
            var newClientProperty = await clientRepository.GetClientPropertyAsync(clientPropertyId);

            newClientProperty.ShouldBeEquivalentTo(clientProperty, options => options.Excluding(o => o.Id).Excluding(x => x.Client));
        }
Example #2
0
        public async Task RemoveClientAsync()
        {
            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")));

            //Remove client
            await clientRepository.RemoveClientAsync(clientEntity);

            //Try Get Removed client
            var removeClientEntity = await clientRepository.GetClientAsync(clientId);

            //Assert removed client - it might be null
            removeClientEntity.Should().BeNull();
        }
Example #3
0
        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();
        }
Example #4
0
        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);
        }
Example #5
0
        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);
        }