public async Task Should_TolerateNullInput()
        {
            PersistenceService.GetPersistedSiteCertificateAsync()
            .Returns(Task.FromResult(ValidCert));

            var output = await Sut.RenewCertificateIfNeeded(null);

            output.Status.Should().Be(LoadedFromStore);
            Assert.AreSame(ValidCert, output.Certificate);
        }
Esempio n. 2
0
        private async Task <bool> TryRetrievingValidPersistedSiteCertificateAsync()
        {
            if (Certificate != null)
            {
                return(false);
            }

            var certificate = await _persistenceService.GetPersistedSiteCertificateAsync();

            if (certificate == null)
            {
                return(false);
            }

            Certificate = certificate;

            if (IsCertificateValid)
            {
                _logger.LogInformation("A persisted non-expired LetsEncrypt certificate was found and will be used.");
                return(true);
            }

            _logger.LogInformation("A persisted but expired LetsEncrypt certificate was found and will be renewed.");

            return(false);
        }
Esempio n. 3
0
        public async Task <CertificateRenewalResult> RenewCertificateIfNeeded(IAbstractCertificate current = null)
        {
            _logger.LogInformation("Checking to see if in-memory LetsEncrypt certificate needs renewal.");
            if (_certificateValidator.IsCertificateValid(current))
            {
                _logger.LogInformation("Current in-memory LetsEncrypt certificate is valid.");
                return(new CertificateRenewalResult(current, CertificateRenewalStatus.Unchanged));
            }

            _logger.LogInformation("Checking to see if existing LetsEncrypt certificate has been persisted and is valid.");
            var persistedSiteCertificate = await _persistenceService.GetPersistedSiteCertificateAsync();

            if (_certificateValidator.IsCertificateValid(persistedSiteCertificate))
            {
                _logger.LogInformation("A persisted non-expired LetsEncrypt certificate was found and will be used: {Thumbprint}", persistedSiteCertificate.Thumbprint);
                return(new CertificateRenewalResult(persistedSiteCertificate, CertificateRenewalStatus.LoadedFromStore));
            }

            _logger.LogInformation("No valid certificate was found. Requesting new certificate from LetsEncrypt.");
            var newCertificate = await RequestNewLetsEncryptCertificate();

            return(new CertificateRenewalResult(newCertificate, CertificateRenewalStatus.Renewed));
        }