Пример #1
0
    def test_validate_config(self):
        feed_url = "http://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/pulp_unittest/"
        importer = YumImporter()
        config = importer_mocks.get_basic_config(feed_url=feed_url)
        repo = mock.Mock(spec=Repository)
        state, msg = importer.validate_config(repo, config, [])
        self.assertTrue(state)

        # Test that an unknown argument in the config throws an error 
        # and the unknown arg is identified in the message
        config = importer_mocks.get_basic_config(feed_url=feed_url, bad_unknown_arg="blah")
        state, msg = importer.validate_config(repo, config, [])
        self.assertFalse(state)
        self.assertTrue("bad_unknown_arg" in msg)
class TestValidateConfig(rpm_support_base.PulpRPMTests):

    def setUp(self):
        super(TestValidateConfig, self).setUp()
        self.temp_dir = tempfile.mkdtemp()
        self.repo = mock.Mock(spec=Repository)
        self.repo.working_dir = os.path.join(self.temp_dir, "repo_working_dir")
        os.makedirs(self.repo.working_dir)
        self.importer = YumImporter()
        self.init()

    def tearDown(self):
        super(TestValidateConfig, self).tearDown()
        shutil.rmtree(self.temp_dir)

    def init(self):
        self.data_dir = os.path.abspath(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../data"))

    def test_config_feed_url(self):

        # test bad feed_url
        feed_url = "fake://example.redhat.com/"
        config = importer_mocks.get_basic_config(feed_url=feed_url)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        feed_url = "http://example.redhat.com/"
        config = importer_mocks.get_basic_config(feed_url=feed_url)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_ssl_verify(self):
        feed_url = "http://example.redhat.com/"
        ssl_verify = "fake"
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_verify=ssl_verify)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        ssl_verify = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_verify=ssl_verify)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)


    def test_config_ssl_ca_cert(self):
        if not M2CRYPTO_HAS_CRL_SUPPORT:
            return
        feed_url = "http://example.redhat.com/"
        ssl_ca_cert = "fake_path_to_ca"
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_ca_cert=ssl_ca_cert)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        ssl_ca_cert = open(os.path.join(self.data_dir, "valid_ca.crt")).read()
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_ca_cert=ssl_ca_cert)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

        ssl_ca_cert_filename = os.path.join(self.repo.working_dir, "ssl_ca_cert")
        self.assertTrue(os.path.exists(ssl_ca_cert_filename))
        ca_cert_data = open(ssl_ca_cert_filename).read()
        self.assertEqual(ca_cert_data, ssl_ca_cert)

    def test_config_ssl_client_cert(self):
        if not M2CRYPTO_HAS_CRL_SUPPORT:
            return
        feed_url = "http://example.redhat.com/"
        ssl_client_cert = "fake_path_to_client_cert"
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_client_cert=ssl_client_cert)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        ssl_client_cert = open(os.path.join(self.data_dir, "cert.crt")).read()
        config = importer_mocks.get_basic_config(feed_url=feed_url, ssl_client_cert=ssl_client_cert)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)
        
        ssl_client_cert_filename = os.path.join(self.repo.working_dir, "ssl_client_cert")
        self.assertTrue(os.path.exists(ssl_client_cert_filename))
        client_cert_data = open(ssl_client_cert_filename).read()
        self.assertEqual(client_cert_data, ssl_client_cert)

    def test_config_proxy_url(self):
        feed_url = "http://example.redhat.com/"
        proxy_url = "fake://proxy"
        config = importer_mocks.get_basic_config(feed_url=feed_url, proxy_url=proxy_url)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        proxy_url = "http://proxy"
        config = importer_mocks.get_basic_config(feed_url=feed_url, proxy_url=proxy_url)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_proxy_port(self):
        config = importer_mocks.get_basic_config(proxy_port=100)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

        config = importer_mocks.get_basic_config(proxy_port='port')
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

    def test_config_max_speed(self):
        feed_url = "http://example.redhat.com/"
        max_speed = "fake_speed"
        config = importer_mocks.get_basic_config(feed_url=feed_url, max_speed=max_speed)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        max_speed = 100
        config = importer_mocks.get_basic_config(feed_url=feed_url, max_speed=max_speed)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_verify_checksum(self):
        feed_url = "http://example.redhat.com/"
        verify_checksum = "fake_bool"
        config = importer_mocks.get_basic_config(feed_url=feed_url, verify_checksum=verify_checksum)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        verify_checksum = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, verify_checksum=verify_checksum)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_verify_size(self):
        feed_url = "http://example.redhat.com/"
        verify_size = "fake_bool"
        config = importer_mocks.get_basic_config(feed_url=feed_url, verify_size=verify_size)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        verify_size = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, verify_size=verify_size)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_newest(self):
        feed_url = "http://example.redhat.com/"
        newest = "fake_bool"
        config = importer_mocks.get_basic_config(feed_url=feed_url, newest=newest)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        newest = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, newest=newest)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_remove_old(self):
        feed_url = "http://example.redhat.com/"
        remove_old  = "fake_bool"
        config = importer_mocks.get_basic_config(feed_url=feed_url, remove_old=remove_old)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        remove_old  = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, remove_old=remove_old)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_num_threads(self):
        feed_url = "http://example.redhat.com/"
        num_threads = "fake_int"
        config = importer_mocks.get_basic_config(feed_url=feed_url, num_threads=num_threads)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        num_threads = 5
        config = importer_mocks.get_basic_config(feed_url=feed_url, num_threads=num_threads)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_num_old_packages(self):
        feed_url = "http://example.redhat.com/"
        num_old_packages = "fake_int"
        config = importer_mocks.get_basic_config(feed_url=feed_url, num_old_packages=num_old_packages)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        num_old_packages = 4
        config = importer_mocks.get_basic_config(feed_url=feed_url, num_old_packages=num_old_packages)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_purge_orphaned(self):
        feed_url = "http://example.redhat.com/"
        purge_orphaned = "fake_bool"
        config = importer_mocks.get_basic_config(feed_url=feed_url, purge_orphaned=purge_orphaned)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        purge_orphaned = True
        config = importer_mocks.get_basic_config(feed_url=feed_url, purge_orphaned=purge_orphaned)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_checksum_type(self):
        feed_url = "http://example.redhat.com/"
        checksum_type ="fake_checksum"
        config = importer_mocks.get_basic_config(feed_url=feed_url, checksum_type=checksum_type)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        checksum_type ="sha"
        config = importer_mocks.get_basic_config(feed_url=feed_url, checksum_type=checksum_type)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)

    def test_config_skip(self):
        feed_url = "http://example.redhat.com/"
        skip_content_types = ""
        config = importer_mocks.get_basic_config(feed_url=feed_url, skip=skip_content_types)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertFalse(state)

        skip_content_types = []
        config = importer_mocks.get_basic_config(feed_url=feed_url, skip=skip_content_types)
        state, msg = self.importer.validate_config(self.repo, config, [])
        self.assertTrue(state)