コード例 #1
0
        public async Task AddApiSecret()
        {
            //Get Services
            var serviceProvider    = GetServices();
            var dbContext          = serviceProvider.GetRequiredService <IdentityServerConfigurationDbContext>();
            var apiResourceService = serviceProvider.GetRequiredService <IApiResourceService>();

            // Get controller
            var controller     = PrepareConfigurationController(serviceProvider);
            var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);
            await apiResourceService.AddApiResourceAsync(apiResourceDto);

            var resource = await dbContext.ApiResources.Where(x => x.Name == apiResourceDto.Name).SingleOrDefaultAsync();

            var apiSecretsDto = ApiResourceDtoMock.GenerateRandomApiSecret(0, resource.Id);

            var result = await controller.ApiSecrets(apiSecretsDto);

            // Assert
            var viewResult = Assert.IsType <RedirectToActionResult>(result);

            viewResult.ActionName.Should().Be("ApiSecrets");

            var apiSecret = await dbContext.ApiSecrets.Where(x => x.Value == apiSecretsDto.Value).SingleOrDefaultAsync();

            var addedApiScope = await apiResourceService.GetApiSecretAsync(apiSecret.Id);

            apiSecretsDto.Should().BeEquivalentTo(addedApiScope, opts => opts.Excluding(x => x.ApiResourceId).Excluding(x => x.ApiResourceName).Excluding(x => x.ApiSecretId));
        }
コード例 #2
0
        public async Task DeleteApiSecret()
        {
            //Get Services
            var serviceProvider    = GetServices();
            var dbContext          = serviceProvider.GetRequiredService <IdentityServerConfigurationDbContext>();
            var apiResourceService = serviceProvider.GetRequiredService <IApiResourceService>();

            // Get controller
            var controller     = PrepareConfigurationController(serviceProvider);
            var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);
            await apiResourceService.AddApiResourceAsync(apiResourceDto);

            var resource = await dbContext.ApiResources.Where(x => x.Name == apiResourceDto.Name).SingleOrDefaultAsync();

            var apiSecretsDto = ApiResourceDtoMock.GenerateRandomApiSecret(0, resource.Id);
            await apiResourceService.AddApiSecretAsync(apiSecretsDto);

            var apiSecretId = await dbContext.ApiSecrets.Where(x => x.Value == apiSecretsDto.Value).Select(x => x.Id)
                              .SingleOrDefaultAsync();

            apiSecretId.Should().NotBe(0);

            apiSecretsDto.ApiSecretId = apiSecretId;
            var result = await controller.ApiSecretDelete(apiSecretsDto);

            // Assert
            var viewResult = Assert.IsType <RedirectToActionResult>(result);

            viewResult.ActionName.Should().Be("ApiSecrets");

            var apiSecret = await dbContext.ApiSecrets.Where(x => x.Id == apiSecretsDto.ApiSecretId).SingleOrDefaultAsync();

            apiSecret.Should().BeNull();
        }
コード例 #3
0
        public async Task GetApiSecrets()
        {
            //Get Services
            var serviceProvider    = GetServices();
            var dbContext          = serviceProvider.GetRequiredService <IdentityServerConfigurationDbContext>();
            var apiResourceService = serviceProvider.GetRequiredService <IApiResourceService>();

            // Get controller
            var controller     = PrepareConfigurationController(serviceProvider);
            var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);
            await apiResourceService.AddApiResourceAsync(apiResourceDto);

            var resource = await dbContext.ApiResources.Where(x => x.Name == apiResourceDto.Name).SingleOrDefaultAsync();

            const int generateApiSecrets = 5;

            for (var i = 0; i < generateApiSecrets; i++)
            {
                var apiSecretsDto = ApiResourceDtoMock.GenerateRandomApiSecret(0, resource.Id);
                await apiResourceService.AddApiSecretAsync(apiSecretsDto);
            }

            var result = await controller.ApiSecrets(resource.Id, 1);

            // Assert
            var viewResult = Assert.IsType <ViewResult>(result);

            viewResult.ViewName.Should().BeNullOrEmpty();
            viewResult.ViewData.Should().NotBeNull();

            var viewModel = Assert.IsType <ApiSecretsDto>(viewResult.ViewData.Model);

            viewModel.ApiSecrets.Count.Should().Be(generateApiSecrets);
        }
コード例 #4
0
        public async Task DeleteApiSecretAsync()
        {
            using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
            {
                IApiResourceRepository apiResourceRepository = new ApiResourceRepository(context);
                IClientRepository      clientRepository      = new ClientRepository(context);

                var localizerApiResourceMock = new Mock <IApiResourceServiceResources>();
                var localizerApiResource     = localizerApiResourceMock.Object;

                var localizerClientResourceMock = new Mock <IClientServiceResources>();
                var localizerClientResource     = localizerClientResourceMock.Object;

                IClientService      clientService      = new ClientService(clientRepository, localizerClientResource);
                IApiResourceService apiResourceService = new ApiResourceService(apiResourceRepository, localizerApiResource, clientService);

                //Generate random new api resource
                var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);

                await apiResourceService.AddApiResourceAsync(apiResourceDto);

                //Get new api resource
                var apiResource = await context.ApiResources.Where(x => x.Name == apiResourceDto.Name).SingleOrDefaultAsync();

                var newApiResourceDto = await apiResourceService.GetApiResourceAsync(apiResource.Id);

                //Assert new api resource
                apiResourceDto.ShouldBeEquivalentTo(newApiResourceDto, options => options.Excluding(o => o.Id));

                //Generate random new api secret
                var apiSecretsDtoMock = ApiResourceDtoMock.GenerateRandomApiSecret(0, newApiResourceDto.Id);

                //Add new api secret
                await apiResourceService.AddApiSecretAsync(apiSecretsDtoMock);

                //Get inserted api secret
                var apiSecret = await context.ApiSecrets.Where(x => x.Value == apiSecretsDtoMock.Value && x.ApiResource.Id == newApiResourceDto.Id)
                                .SingleOrDefaultAsync();

                //Map entity to model
                var apiSecretsDto = apiSecret.ToModel();

                //Get new api secret
                var newApiSecret = await apiResourceService.GetApiSecretAsync(apiSecretsDto.ApiSecretId);

                //Assert
                newApiSecret.ShouldBeEquivalentTo(apiSecretsDto, o => o.Excluding(x => x.ApiResourceName));

                //Delete it
                await apiResourceService.DeleteApiSecretAsync(newApiSecret);

                var deletedApiSecret = await context.ApiSecrets.Where(x => x.Value == apiSecretsDtoMock.Value && x.ApiResource.Id == newApiResourceDto.Id)
                                       .SingleOrDefaultAsync();

                //Assert after deleting
                deletedApiSecret.Should().BeNull();
            }
        }
コード例 #5
0
        public async Task DeleteApiSecretAsync()
        {
            IApiResourceRepository apiResourceRepository = new ApiResourceDapperRepository(_configuration);
            IClientRepository      clientRepository      = new ClientDapperRepository(_configuration);

            var localizerApiResourceMock = new Mock <IApiResourceServiceResources>();
            var localizerApiResource     = localizerApiResourceMock.Object;

            var localizerClientResourceMock = new Mock <IClientServiceResources>();
            var localizerClientResource     = localizerClientResourceMock.Object;

            IClientService      clientService      = new ClientService(clientRepository, localizerClientResource);
            IApiResourceService apiResourceService = new ApiResourceService(apiResourceRepository, localizerApiResource, clientService);

            //Generate random new api resource
            var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);

            var apiResourceDtoId = await apiResourceService.AddApiResourceAsync(apiResourceDto);

            //Get new api resource
            var newApiResourceDto = await apiResourceService.GetApiResourceAsync(apiResourceDtoId);

            //Assert new api resource
            apiResourceDto.ShouldBeEquivalentTo(newApiResourceDto, options => options.Excluding(o => o.Id));

            //Generate random new api secret
            var apiSecretsDtoMock = ApiResourceDtoMock.GenerateRandomApiSecret(0, newApiResourceDto.Id);

            //Add new api secret
            var apiSecretId = await apiResourceService.AddApiSecretAsync(apiSecretsDtoMock);

            //Get inserted api secret
            var apiSecret = await apiResourceRepository.GetApiSecretAsync(apiSecretId);

            //Map entity to model
            var apiSecretsDto = apiSecret.ToModel();

            //Get new api secret
            var newApiSecret = await apiResourceService.GetApiSecretAsync(apiSecretsDto.ApiSecretId);

            //Assert
            newApiSecret.ShouldBeEquivalentTo(apiSecretsDto, o => o.Excluding(x => x.ApiResourceName));

            //Delete it
            await apiResourceService.DeleteApiSecretAsync(newApiSecret);

            var deletedApiSecret = await apiResourceRepository.GetApiSecretAsync(apiSecretId);

            //Assert after deleting
            deletedApiSecret.Should().BeNull();
        }
コード例 #6
0
        public async Task DeleteApiSecretAsync()
        {
            using (var context = new IdentityServerConfigurationDbContext(_dbContextOptions, _storeOptions))
            {
                var apiResourceService = GetApiResourceService(context);

                //Generate random new api resource
                var apiResourceDto = ApiResourceDtoMock.GenerateRandomApiResource(0);

                await apiResourceService.AddApiResourceAsync(apiResourceDto);

                //Get new api resource
                var apiResource = await context.ApiResources.Where(x => x.Name == apiResourceDto.Name).SingleOrDefaultAsync();

                var newApiResourceDto = await apiResourceService.GetApiResourceAsync(apiResource.Id);

                //Assert new api resource
                apiResourceDto.Should().BeEquivalentTo(newApiResourceDto, options => options.Excluding(o => o.Id));

                //Generate random new api secret
                var apiSecretsDtoMock = ApiResourceDtoMock.GenerateRandomApiSecret(0, newApiResourceDto.Id);

                //Add new api secret
                await apiResourceService.AddApiSecretAsync(apiSecretsDtoMock);

                //Get inserted api secret
                var apiSecret = await context.ApiSecrets.Where(x => x.Value == apiSecretsDtoMock.Value && x.ApiResource.Id == newApiResourceDto.Id)
                                .SingleOrDefaultAsync();

                //Map entity to model
                var apiSecretsDto = apiSecret.ToModel();

                //Get new api secret
                var newApiSecret = await apiResourceService.GetApiSecretAsync(apiSecretsDto.ApiSecretId);

                // Assert
                newApiSecret.Should().BeEquivalentTo(apiSecretsDto, o => o.Excluding(x => x.ApiResourceName).Excluding(x => x.Value));

                apiSecretsDto.Value.Should().Be(apiSecretsDtoMock.Value);

                //Delete it
                await apiResourceService.DeleteApiSecretAsync(newApiSecret);

                var deletedApiSecret = await context.ApiSecrets.Where(x => x.Value == apiSecretsDtoMock.Value && x.ApiResource.Id == newApiResourceDto.Id)
                                       .SingleOrDefaultAsync();

                //Assert after deleting
                deletedApiSecret.Should().BeNull();
            }
        }
コード例 #7
0
        public void CanMapApiSecretDtoToEntity()
        {
            //Generate DTO
            var apiSecretsDto = ApiResourceDtoMock.GenerateRandomApiSecret(1, 1);

            //Try map to entity
            var apiSecret = apiSecretsDto.ToEntity();

            apiSecret.Should().NotBeNull();

            apiSecret.Should().BeEquivalentTo(apiSecretsDto);

            apiSecret.Id.Should().Be(apiSecretsDto.ApiSecretId);
        }
コード例 #8
0
        public void CanMapApiSecretDtoToEntity()
        {
            //Generate DTO
            var apiSecretsDto = ApiResourceDtoMock.GenerateRandomApiSecret(1, 1);

            //Try map to entity
            var apiSecret = apiSecretsDto.ToEntity();

            apiSecret.Should().NotBeNull();

            apiSecret.ShouldBeEquivalentTo(apiSecretsDto, options =>
                                           options.Excluding(o => o.ApiResource)
                                           .Excluding(o => o.Created)
                                           .Excluding(o => o.Id));

            apiSecret.Id.Should().Be(apiSecretsDto.ApiSecretId);
        }