Exemple #1
0
        public async Task DeleteClientSecretAsync()
        {
            IClientRepository clientRepository = new ClientDapperRepository(_configuration);

            var localizerMock = new Mock <IClientServiceResources>();
            var localizer     = localizerMock.Object;

            IClientService clientService = new ClientService(clientRepository, localizer);

            //Generate random new client
            var client = ClientDtoMock.GenerateRandomClient(0);

            var clientId = await clientService.AddClientAsync(client);

            //Get new client
            var clientEntity = await clientRepository.GetClientAsync(clientId);

            var clientDto = await clientService.GetClientAsync(clientEntity.Id);

            //Assert new client
            client.ShouldBeEquivalentTo(clientDto, options => options.Excluding(o => o.Id));

            //Generate random new Client secret
            var clientSecret = ClientDtoMock.GenerateRandomClientSecret(0, clientEntity.Id);

            //Add new client secret
            var clientSecretId = await clientService.AddClientSecretAsync(clientSecret);

            //Get inserted client property
            var secret = await clientRepository.GetClientSecretAsync(clientSecretId);

            //Map entity to model
            var secretsDto = secret.ToModel();

            //Get new client secret
            var clientSecretsDto = await clientService.GetClientSecretAsync(secret.Id);

            //Assert
            clientSecretsDto.ShouldBeEquivalentTo(secretsDto, options => options.Excluding(o => o.ClientSecretId));

            //Delete client secret
            await clientService.DeleteClientSecretAsync(clientSecretsDto);

            //Get removed client secret
            var deleteClientSecret = await clientRepository.GetClientSecretAsync(secret.Id);

            //Assert after delete it
            deleteClientSecret.Should().BeNull();
        }
Exemple #2
0
        public async Task GetClientSecretAsync()
        {
            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);

            newSecret.ShouldBeEquivalentTo(clientSecret, options => options.Excluding(o => o.Id).Excluding(x => x.Client).Excluding(x => x.Expiration));
        }