File Manager Sederhana

Nama	Ukuran	Izin	Aksi
__pycache__	-	0755	-
compat	-	0755	-
display	-	0755	-
plugins	-	0755	-
__init__.py	20 B	0644	Edit Rename Delete
account_test.py	13.94 KB	0644	Edit Rename Delete
auth_handler_test.py	24.45 KB	0644	Edit Rename Delete
cert_manager_test.py	28.75 KB	0644	Edit Rename Delete
cli_test.py	25.59 KB	0644	Edit Rename Delete
client_test.py	50.59 KB	0644	Edit Rename Delete
configuration_test.py	6.96 KB	0644	Edit Rename Delete
crypto_util_test.py	18.37 KB	0644	Edit Rename Delete
eff_test.py	6.52 KB	0644	Edit Rename Delete
error_handler_test.py	5.08 KB	0644	Edit Rename Delete
errors_test.py	1.91 KB	0644	Edit Rename Delete
helpful_test.py	4.87 KB	0644	Edit Rename Delete
hook_test.py	17.62 KB	0644	Edit Rename Delete
lock_test.py	4.94 KB	0644	Edit Rename Delete
log_test.py	15.58 KB	0644	Edit Rename Delete
main_test.py	120.23 KB	0644	Edit Rename Delete
ocsp_test.py	17.09 KB	0644	Edit Rename Delete
renewal_test.py	14.59 KB	0644	Edit Rename Delete
renewupdater_test.py	5.38 KB	0644	Edit Rename Delete
reverter_test.py	16.6 KB	0644	Edit Rename Delete
storage_test.py	46.03 KB	0644	Edit Rename Delete
util_test.py	24.18 KB	0644	Edit Rename Delete

Edit File:client_test.py

"""Tests for certbot._internal.client."""
import contextlib
import datetime
import platform
import shutil
import sys
import tempfile
import unittest
from unittest import mock
from unittest.mock import MagicMock

from josepy import interfaces
import pytest

from certbot import errors
from certbot import util
from certbot._internal import account
from certbot._internal import constants
from certbot._internal.display import obj as display_obj
from certbot.compat import os
import certbot.tests.util as test_util

KEY = test_util.load_vector("rsa512_key.pem")
CSR_SAN = test_util.load_vector("csr-san_512.pem")

# pylint: disable=line-too-long

class DetermineUserAgentTest(test_util.ConfigTestCase):
    """Tests for certbot._internal.client.determine_user_agent."""

def _call(self):
        from certbot._internal.client import determine_user_agent
        return determine_user_agent(self.config)

@mock.patch.dict(os.environ, {"CERTBOT_DOCS": "1"})
    def test_docs_value(self):
        self._test(expect_doc_values=True)

@mock.patch.dict(os.environ, {})
    def test_real_values(self):
        self._test(expect_doc_values=False)

def _test(self, expect_doc_values):
        ua = self._call()

if expect_doc_values:
            doc_value_check = self.assertIn
            real_value_check = self.assertNotIn
        else:
            doc_value_check = self.assertNotIn
            real_value_check = self.assertIn

doc_value_check("OS_NAME OS_VERSION", ua)
        doc_value_check("major.minor.patchlevel", ua)
        real_value_check(util.get_os_info_ua(), ua)
        real_value_check(platform.python_version(), ua)

class RegisterTest(test_util.ConfigTestCase):
    """Tests for certbot._internal.client.register."""

def setUp(self):
        super().setUp()
        self.config.rsa_key_size = 1024
        self.config.register_unsafely_without_email = False
        self.config.email = "alias@example.com"
        self.account_storage = account.AccountMemoryStorage()
        self.tos_cb = mock.MagicMock()
        display_obj.set_display(MagicMock())

def _call(self):
        from certbot._internal.client import register
        return register(self.config, self.account_storage, self.tos_cb)

@staticmethod
    def _public_key_mock():
        m = mock.Mock(__class__=interfaces.JSONDeSerializable)
        m.to_partial_json.return_value = '{"a": 1}'
        return m

@staticmethod
    def _new_acct_dir_mock():
        return "/acme/new-account"

@staticmethod
    def _true_mock():
        return True

@staticmethod
    def _false_mock():
        return False

@staticmethod
    @contextlib.contextmanager
    def _patched_acme_client():
        with mock.patch('certbot._internal.client.acme_client') as mock_acme_client:
            yield mock_acme_client.ClientV2

def test_no_tos(self):
        with self._patched_acme_client() as mock_client:
            mock_client.new_account().terms_of_service = "http://tos"
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.prepare_subscription") as mock_prepare:
                mock_client().new_account.side_effect = errors.Error
                with pytest.raises(errors.Error):
                    self._call()
                assert mock_prepare.called is False

mock_client().new_account.side_effect = None
                self._call()
                assert mock_prepare.called is True

@mock.patch('certbot._internal.eff.prepare_subscription')
    def test_empty_meta(self, unused_mock_prepare):
        # Test that we can handle an ACME server which does not implement the 'meta'
        # directory object (for terms-of-service handling).
        with self._patched_acme_client() as mock_client:
            from acme.messages import Directory
            mock_client().directory = Directory.from_json({})

mock_client().external_account_required.side_effect = self._false_mock

self._call()
            assert self.tos_cb.called is False

@test_util.patch_display_util()
    def test_it(self, unused_mock_get_utility):
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                self._call()
            assert self.tos_cb.called is True

@mock.patch("certbot._internal.client.display_ops.get_email")
    def test_email_retry(self, mock_get_email):
        from acme import messages
        self.config.noninteractive_mode = False
        msg = "DNS problem: NXDOMAIN looking up MX for example.com"
        mx_err = messages.Error.with_code('invalidContact', detail=msg)
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.prepare_subscription") as mock_prepare:
                mock_client().new_account.side_effect = [mx_err, mock.MagicMock()]
                self._call()
                assert mock_get_email.call_count == 1
                assert mock_prepare.called is True

def test_email_invalid_noninteractive(self):
        from acme import messages
        self.config.noninteractive_mode = True
        msg = "DNS problem: NXDOMAIN looking up MX for example.com"
        mx_err = messages.Error.with_code('invalidContact', detail=msg)
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                mock_client().new_account.side_effect = [mx_err, mock.MagicMock()]
                with pytest.raises(errors.Error):
                    self._call()

def test_no_email_is_chill(self):
        self.config.email = None
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            self._call()

@mock.patch("certbot._internal.client.logger")
    def test_without_email(self, mock_logger):
        with mock.patch("certbot._internal.eff.prepare_subscription") as mock_prepare:
            with self._patched_acme_client() as mock_client:
                mock_client().external_account_required.side_effect = self._false_mock
                self.config.email = None
                self.config.register_unsafely_without_email = True
                self.config.dry_run = False
                self._call()
                assert mock_prepare.called is True

@mock.patch("certbot._internal.client.display_ops.get_email")
    def test_dry_run_no_staging_account(self, mock_get_email):
        """Tests dry-run for no staging account, expect account created with no email"""
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                self.config.dry_run = True
                self._call()
                # check Certbot did not ask the user to provide an email
                assert mock_get_email.called is False
                # check Certbot created an account with no email. Contact should return empty
                assert not mock_client().new_account.call_args[0][0].contact

@test_util.patch_display_util()
    def test_with_eab_arguments(self, unused_mock_get_utility):
        with self._patched_acme_client() as mock_client:
            mock_client().client.directory.__getitem__ = mock.Mock(
                side_effect=self._new_acct_dir_mock
            )
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                target = "certbot._internal.client.messages.ExternalAccountBinding.from_data"
                with mock.patch(target) as mock_eab_from_data:
                    self.config.eab_kid = "test-kid"
                    self.config.eab_hmac_key = "J2OAqW4MHXsrHVa_PVg0Y-L_R4SYw0_aL1le6mfblbE"
                    self._call()

assert mock_eab_from_data.called is True

@test_util.patch_display_util()
    def test_without_eab_arguments(self, unused_mock_get_utility):
        with self._patched_acme_client() as mock_client:
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                target = "certbot._internal.client.messages.ExternalAccountBinding.from_data"
                with mock.patch(target) as mock_eab_from_data:
                    self.config.eab_kid = None
                    self.config.eab_hmac_key = None
                    self._call()

assert mock_eab_from_data.called is False

def test_external_account_required_without_eab_arguments(self):
        with self._patched_acme_client() as mock_client:
            mock_client().client.net.key.public_key = mock.Mock(side_effect=self._public_key_mock)
            mock_client().external_account_required.side_effect = self._true_mock
            with mock.patch("certbot._internal.eff.handle_subscription"):
                with mock.patch("certbot._internal.client.messages.ExternalAccountBinding.from_data"):
                    self.config.eab_kid = None
                    self.config.eab_hmac_key = None

with pytest.raises(errors.Error):
                        self._call()

def test_unsupported_error(self):
        from acme import messages
        msg = "Test"
        mx_err = messages.Error.with_code("malformed", detail=msg, title="title")
        with self._patched_acme_client() as mock_client:
            mock_client().client.directory.__getitem__ = mock.Mock(
                side_effect=self._new_acct_dir_mock
            )
            mock_client().external_account_required.side_effect = self._false_mock
            with mock.patch("certbot._internal.eff.handle_subscription") as mock_handle:
                mock_client().new_account.side_effect = [mx_err, mock.MagicMock()]
                with pytest.raises(messages.Error):
                    self._call()
        assert mock_handle.called is False

class ClientTestCommon(test_util.ConfigTestCase):
    """Common base class for certbot._internal.client.Client tests."""

def setUp(self):
        super().setUp()
        self.config.no_verify_ssl = False
        self.config.allow_subset_of_names = False

self.account = mock.MagicMock(**{"key.pem": KEY})

from certbot._internal.client import Client
        with mock.patch("certbot._internal.client.acme_client") as acme:
            self.acme_client = acme.ClientV2
            self.acme = self.acme_client.return_value = mock.MagicMock()
            self.client_network = acme.ClientNetwork
            self.client = Client(
                config=self.config, account_=self.account,
                auth=None, installer=None)

class ClientTest(ClientTestCommon):
    """Tests for certbot._internal.client.Client."""

def setUp(self):
        super().setUp()

self.config.allow_subset_of_names = False
        self.config.dry_run = False
        self.config.strict_permissions = True
        self.eg_domains = ["example.com", "www.example.com"]
        self.eg_order = mock.MagicMock(
            authorizations=[None],
            csr_pem=mock.sentinel.csr_pem)

def test_init_acme_verify_ssl(self):
        assert self.client_network.call_args[1]['verify_ssl'] is True

def _mock_obtain_certificate(self):
        self.client.auth_handler = mock.MagicMock()
        self.client.auth_handler.handle_authorizations.return_value = [None]
        self.client.auth_handler.deactivate_valid_authorizations.return_value = ([], [])
        self.acme.finalize_order.return_value = self.eg_order
        self.acme.new_order.return_value = self.eg_order
        self.eg_order.update.return_value = self.eg_order

def _check_obtain_certificate(self, auth_count=1):
        if auth_count == 1:
            self.client.auth_handler.handle_authorizations.assert_called_once_with(
                self.eg_order,
                self.config,
                self.config.allow_subset_of_names)
        else:
            assert self.client.auth_handler.handle_authorizations.call_count == auth_count

self.acme.finalize_order.assert_called_once_with(
            self.eg_order, mock.ANY,
            fetch_alternative_chains=self.config.preferred_chain is not None)

@mock.patch("certbot._internal.client.crypto_util")
    @mock.patch("certbot._internal.client.logger")
    def test_obtain_certificate_from_csr(self, mock_logger, mock_crypto_util):
        self._mock_obtain_certificate()
        test_csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        auth_handler = self.client.auth_handler
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

orderr = self.acme.new_order(test_csr.data)
        auth_handler.handle_authorizations(orderr, self.config, False)
        assert (mock.sentinel.cert, mock.sentinel.chain) == \
            self.client.obtain_certificate_from_csr(
                test_csr,
                orderr=orderr)
        mock_crypto_util.find_chain_with_issuer.assert_not_called()
        # and that the cert was obtained correctly
        self._check_obtain_certificate()

# Test that --preferred-chain results in chain selection
        self.config.preferred_chain = "some issuer"
        assert (mock.sentinel.cert, mock.sentinel.chain) == \
            self.client.obtain_certificate_from_csr(
                test_csr,
                orderr=orderr)
        mock_crypto_util.find_chain_with_issuer.assert_called_once_with(
            [orderr.fullchain_pem] + orderr.alternative_fullchains_pem,
            "some issuer", True)
        self.config.preferred_chain = None

# Test for default issuance_timeout
        expected_deadline = \
            datetime.datetime.now() + datetime.timedelta(
                seconds=constants.CLI_DEFAULTS["issuance_timeout"])
        self.client.obtain_certificate_from_csr(test_csr, orderr=orderr)
        ((_, deadline), _) = self.client.acme.finalize_order.call_args
        assert abs(expected_deadline - deadline) <= datetime.timedelta(seconds=1)

# Test for specific issuance_timeout (300 seconds)
        expected_deadline = \
            datetime.datetime.now() + datetime.timedelta(seconds=300)
        self.config.issuance_timeout = 300
        self.client.obtain_certificate_from_csr(test_csr, orderr=orderr)
        ((_, deadline), _) = self.client.acme.finalize_order.call_args
        assert abs(expected_deadline - deadline) <= datetime.timedelta(seconds=1)

# Test for orderr=None
        assert (mock.sentinel.cert, mock.sentinel.chain) == \
            self.client.obtain_certificate_from_csr(
                test_csr,
                orderr=None)
        auth_handler.handle_authorizations.assert_called_with(self.eg_order, self.config, False)

# Test for no auth_handler
        self.client.auth_handler = None
        with pytest.raises(errors.Error):
            self.client.obtain_certificate_from_csr(test_csr)
        mock_logger.error.assert_called_once_with(mock.ANY)

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self._test_obtain_certificate_common(mock.sentinel.key, csr)

mock_crypto_util.generate_key.assert_called_once_with(
            key_size=self.config.rsa_key_size,
            key_dir=None,
            key_type=self.config.key_type,
            elliptic_curve="secp256r1",
            strict_permissions=True,
        )
        mock_crypto_util.generate_csr.assert_called_once_with(
            mock.sentinel.key, self.eg_domains, None, False, True)
        mock_crypto_util.cert_and_chain_from_fullchain.assert_called_once_with(
            self.eg_order.fullchain_pem)

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_no_profile_preference(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self.client.config.required_profile = None
        self.client.config.preferred_profile = None

self._test_obtain_certificate_common(mock.sentinel.key, csr)
        self.acme.new_order.assert_called_once_with(mock.ANY, profile=None)

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_required_profile(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self.client.config.required_profile = "exampleProfile"
        self.client.config.preferred_profile = None

self._test_obtain_certificate_common(mock.sentinel.key, csr)
        self.acme.new_order.assert_called_once_with(mock.ANY, profile="exampleProfile")

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_preferred_profile_exists(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self.client.config.required_profile = None
        self.client.config.preferred_profile = "exampleProfile"

from acme.messages import Directory
        self.acme.directory = Directory.from_json({
            'meta': {
                'profiles': {
                    'exampleProfile': 'here is some descriptive text, very informative',
                }
            }
        })

self._test_obtain_certificate_common(mock.sentinel.key, csr)
        self.acme.new_order.assert_called_once_with(mock.ANY, profile="exampleProfile")

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_preferred_profile_does_not_exist(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self.client.config.required_profile = None
        self.client.config.preferred_profile = "thisProfileDoesNotExist"

from acme.messages import Directory
        self.acme.directory = Directory.from_json({
            'meta': {
                'profiles': {
                    'example': 'profiles!',
                }
            }
        })

self._test_obtain_certificate_common(mock.sentinel.key, csr)
        self.acme.new_order.assert_called_once_with(mock.ANY, profile=None)

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_preferred_profile_no_profiles_exist(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=None, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = mock.sentinel.key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self.client.config.required_profile = None
        self.client.config.preferred_profile = "thisProfileDoesNotExist"

from acme.messages import Directory
        self.acme.directory = Directory.from_json({})

self._test_obtain_certificate_common(mock.sentinel.key, csr)
        self.acme.new_order.assert_called_once_with(mock.ANY, profile=None)

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_partial_success(self, mock_crypto_util):
        csr = util.CSR(form="pem", file=mock.sentinel.csr_file, data=CSR_SAN)
        key = util.CSR(form="pem", file=mock.sentinel.key_file, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

authzr = self._authzr_from_domains(["example.com"])
        self.config.allow_subset_of_names = True
        self._test_obtain_certificate_common(key, csr, authzr_ret=authzr, auth_count=2)

assert mock_crypto_util.generate_key.call_count == 2
        assert mock_crypto_util.generate_csr.call_count == 2
        assert mock_crypto_util.cert_and_chain_from_fullchain.call_count == 1

@mock.patch("certbot._internal.client.crypto_util")
    def test_obtain_certificate_finalize_order_partial_success(self, mock_crypto_util):
        from acme import messages
        csr = util.CSR(form="pem", file=mock.sentinel.csr_file, data=CSR_SAN)
        key = util.CSR(form="pem", file=mock.sentinel.key_file, data=CSR_SAN)
        mock_crypto_util.generate_csr.return_value = csr
        mock_crypto_util.generate_key.return_value = key
        self._set_mock_from_fullchain(mock_crypto_util.cert_and_chain_from_fullchain)

self._mock_obtain_certificate()
        authzr = self._authzr_from_domains(self.eg_domains)
        self.eg_order.authorizations = authzr
        self.client.auth_handler.handle_authorizations.return_value = authzr

identifier = messages.Identifier(typ=messages.IDENTIFIER_FQDN, value='example.com')
        subproblem = messages.Error.with_code('caa', detail='bar', title='title', identifier=identifier)
        error_with_subproblems = messages.Error.with_code('malformed', detail='foo', title='title', subproblems=[subproblem])
        self.client.acme.finalize_order.side_effect = [error_with_subproblems, mock.DEFAULT]