pyproxytools 0.3.2__py3-none-any.whl

tests/modules/test_shortcuts.py

@@ -0,0 +1,119 @@
+"""
+test_shortcuts.py
+
+This module contains unit tests for the `shortcuts.py` module.
+It verifies the correct functionality of loading shortcuts and resolving aliases.
+
+Tested Functions:
+- load_shortcuts: Ensures that the shortcut file is correctly loaded
+                and the alias-URL mappings are correct.
+- shortcuts_process: Ensures that alias requests are correctly processed
+                and resolved to their corresponding URLs.
+
+Test Cases:
+- TestLoadShortcuts: Checks the correct loading of alias-URL mappings from the file.
+- TestShortcutsProcess: Verifies that alias requests are correctly resolved to URLs.
+- TestLoadShortcutsFileNotFound: Verifies that a FileNotFoundError is raised
+                when the shortcuts file is missing.
+- TestShortcutsProcessWithAliasRequest: Verifies that the process correctly
+                resolves alias requests to URLs.
+- TestShortcutsProcessFileMonitor: Verifies that the file monitor thread correctly
+                updates the shortcuts when the file is changed.
+"""
+
+import unittest
+import multiprocessing
+from unittest.mock import patch, mock_open
+from pyproxy.modules.shortcuts import load_shortcuts, shortcuts_process
+
+
+class TestShortcuts(unittest.TestCase):
+    """
+    Test suite for the shortcuts module.
+    """
+
+    def setUp(self):
+        """Sets up the common resources for tests."""
+        self.queue = multiprocessing.Queue()
+        self.result_queue = multiprocessing.Queue()
+
+    def tearDown(self):
+        """Cleans up after each test."""
+        while not self.queue.empty():
+            self.queue.get_nowait()
+        while not self.result_queue.empty():
+            self.result_queue.get_nowait()
+
+    def test_load_shortcuts(self):
+        """Tests if the shortcuts are correctly loaded from the file."""
+        with patch(
+            "builtins.open",
+            new_callable=mock_open,
+            read_data="alias1=http://example.com\nalias2=http://test.com",
+        ):
+            shortcuts = load_shortcuts("shortcuts.txt")
+            self.assertEqual(shortcuts["alias1"], "http://example.com")
+            self.assertEqual(shortcuts["alias2"], "http://test.com")
+            self.assertIsInstance(shortcuts, dict)
+
+    @patch("builtins.open", side_effect=FileNotFoundError("File not found"))
+    def test_load_shortcuts_file_not_found(self, _mock_file):
+        """Tests that a FileNotFoundError is raised when the shortcuts file is missing."""
+        with self.assertRaises(FileNotFoundError):
+            load_shortcuts("invalid_file.txt")
+
+    def _test_shortcuts_process_helper(
+        self, alias, expected_url, patch_data="alias1=http://example.com"
+    ):
+        """Helper method to test shortcuts_process with different alias requests."""
+        with patch("builtins.open", new_callable=mock_open, read_data=patch_data):
+            process = multiprocessing.Process(
+                target=shortcuts_process,
+                args=(self.queue, self.result_queue, "shortcuts.txt"),
+            )
+            process.start()
+
+            self.queue.put(alias)
+
+            result = self.result_queue.get(timeout=2)
+            self.assertEqual(result, expected_url)
+
+            process.terminate()
+            process.join()
+
+    def test_shortcuts_process(self):
+        """Tests if alias requests are correctly resolved to URLs."""
+        self._test_shortcuts_process_helper("alias1", "http://example.com")
+
+    def test_shortcuts_process_invalid_alias(self):
+        """Tests if an invalid alias returns None."""
+        self._test_shortcuts_process_helper("invalid_alias", None)
+
+    def test_shortcuts_process_with_multiple_aliases(self):
+        """Tests if multiple alias requests are correctly resolved."""
+        with patch(
+            "builtins.open",
+            new_callable=mock_open,
+            read_data="alias1=http://example.com\nalias2=http://test.com",
+        ):
+            process = multiprocessing.Process(
+                target=shortcuts_process,
+                args=(self.queue, self.result_queue, "shortcuts.txt"),
+            )
+            process.start()
+
+            self.queue.put("alias1")
+            self.queue.put("alias2")
+
+            result1 = self.result_queue.get(timeout=2)
+            result2 = self.result_queue.get(timeout=2)
+
+            self.assertEqual(result1, "http://example.com")
+            self.assertEqual(result2, "http://test.com")
+
+            process.terminate()
+            process.join()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_crypto.py

@@ -0,0 +1,110 @@
+"""
+tests.utils.test_crypto.py
+
+This module contains unit tests for the `crypto.py` module in the `pyproxy.utils` package.
+"""
+
+import unittest
+import os
+import tempfile
+from OpenSSL import crypto
+from pyproxy.utils.crypto import generate_certificate
+
+
+class TestCrypto(unittest.TestCase):
+    """
+    Test suite for the crypto module.
+    """
+
+    def setUp(self):
+        """
+        Set up a fake CA certificate and private key for testing.
+        """
+        self.certs_folder = tempfile.mkdtemp()
+        self.domain = "example.com"
+        self.ca_cert_path = os.path.join(self.certs_folder, "ca_cert.pem")
+        self.ca_key_path = os.path.join(self.certs_folder, "ca_key.pem")
+
+        self._generate_fake_ca()
+
+    def _generate_fake_ca(self):
+        """
+        Generate a fake self-signed CA certificate and key for testing purposes.
+        """
+        ca_key = crypto.PKey()
+        ca_key.generate_key(crypto.TYPE_RSA, 2048)
+
+        ca_cert = crypto.X509()
+        ca_cert.set_serial_number(1000)
+        ca_cert.get_subject().CN = "Fake CA"
+        ca_cert.gmtime_adj_notBefore(0)
+        ca_cert.gmtime_adj_notAfter(365 * 24 * 60 * 60)
+        ca_cert.set_issuer(ca_cert.get_subject())
+        ca_cert.set_pubkey(ca_key)
+
+        ca_cert.sign(ca_key, "sha256")
+
+        with open(self.ca_cert_path, "wb") as cert_file:
+            cert_file.write(crypto.dump_certificate(crypto.FILETYPE_PEM, ca_cert))
+        with open(self.ca_key_path, "wb") as key_file:
+            key_file.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, ca_key))
+
+    def test_generate_certificate(self):
+        """
+        Test the `generate_certificate` function to ensure it generates a certificate
+        and private key file for a given domain.
+        """
+        if not self.certs_folder.endswith("/"):
+            self.certs_folder += "/"
+        cert_path, key_path = generate_certificate(
+            self.domain, self.certs_folder, self.ca_cert_path, self.ca_key_path
+        )
+
+        expected_cert_path = os.path.join(self.certs_folder, f"{self.domain}.pem")
+        expected_key_path = os.path.join(self.certs_folder, f"{self.domain}.key")
+
+        self.assertEqual(cert_path, expected_cert_path)
+        self.assertEqual(key_path, expected_key_path)
+
+        self.assertTrue(os.path.exists(cert_path))
+        self.assertTrue(os.path.exists(key_path))
+
+        with open(cert_path, "rb") as cert_file:
+            cert_data = cert_file.read()
+            cert = crypto.load_certificate(crypto.FILETYPE_PEM, cert_data)
+
+        with open(key_path, "rb") as key_file:
+            key_data = key_file.read()
+            key = crypto.load_privatekey(crypto.FILETYPE_PEM, key_data)
+
+        self.assertEqual(
+            crypto.dump_publickey(crypto.FILETYPE_PEM, cert.get_pubkey()),
+            crypto.dump_publickey(crypto.FILETYPE_PEM, key),
+        )
+
+    def tearDown(self):
+        """
+        Cleanup method executed after each test.
+
+        - Deletes the generated certificate and key files if they exist.
+        - Removes the fake CA files.
+        """
+        cert_path = os.path.join(self.certs_folder, f"{self.domain}.pem")
+        key_path = os.path.join(self.certs_folder, f"{self.domain}.key")
+
+        if os.path.exists(cert_path):
+            os.remove(cert_path)
+        if os.path.exists(key_path):
+            os.remove(key_path)
+
+        if os.path.exists(self.ca_cert_path):
+            os.remove(self.ca_cert_path)
+        if os.path.exists(self.ca_key_path):
+            os.remove(self.ca_key_path)
+
+        if os.path.exists(self.certs_folder):
+            os.rmdir(self.certs_folder)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_http_req.py

@@ -0,0 +1,69 @@
+"""
+tests.utils.test_http_req.py
+
+This module contains unit tests for the `http_req.py` module in the `pyproxy.utils` package.
+"""
+
+import unittest
+from pyproxy.utils.http_req import extract_headers, parse_url
+
+
+class TestHttpReq(unittest.TestCase):
+    """
+    Test suite for the HTTP request utilities.
+    """
+
+    def test_extract_headers(self):
+        """
+        Test the `extract_headers` function to ensure it correctly parses the headers
+        from an HTTP request string.
+        """
+
+        request_str = """GET / HTTP/1.1
+Host: example.com
+User-Agent: Mozilla/5.0
+Accept: */*
+
+"""
+        expected_headers = {
+            "Host": "example.com",
+            "User-Agent": "Mozilla/5.0",
+            "Accept": "*/*",
+        }
+
+        headers = extract_headers(request_str)
+        self.assertEqual(headers, expected_headers)
+
+    def test_parse_url(self):
+        """
+        Test the `parse_url` function to ensure it correctly extracts the host and port
+        from a URL.
+        """
+
+        url = "http://example.com:8080/path/to/resource"
+        expected_host, expected_port = "example.com", 8080
+        host, port = parse_url(url)
+        self.assertEqual(host, expected_host)
+        self.assertEqual(port, expected_port)
+
+        url = "http://example.com/path/to/resource"
+        expected_host, expected_port = "example.com", 80
+        host, port = parse_url(url)
+        self.assertEqual(host, expected_host)
+        self.assertEqual(port, expected_port)
+
+        url = "example.com:9090"
+        expected_host, expected_port = "example.com", 9090
+        host, port = parse_url(url)
+        self.assertEqual(host, expected_host)
+        self.assertEqual(port, expected_port)
+
+        url = "example.com"
+        expected_host, expected_port = "example.com", 80
+        host, port = parse_url(url)
+        self.assertEqual(host, expected_host)
+        self.assertEqual(port, expected_port)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_logger.py

@@ -0,0 +1,68 @@
+"""
+tests.utils.test_logger.py
+
+This module contains unit tests for the `logger.py` module.
+It verifies the correct configuration of both console and file loggers.
+"""
+
+import unittest
+import logging
+import os
+from unittest.mock import patch, MagicMock
+from pyproxy.utils.logger import configure_console_logger, configure_file_logger
+
+
+class TestLogger(unittest.TestCase):
+    """
+    Test suite for the logger module.
+    """
+
+    @patch("sys.stdout")
+    def test_configure_console_logger(self, mock_stdout):
+        """
+        Test that the console logger is correctly configured.
+
+        - Ensures the logger has at least one handler.
+        - Checks that the log level is set to INFO.
+        - Verifies that the handler is a StreamHandler.
+        """
+        logger = configure_console_logger()
+
+        self.assertTrue(logger.hasHandlers())
+        self.assertEqual(logger.level, logging.INFO)
+        handler_types = [type(handler) for handler in logger.handlers]
+        self.assertIn(logging.StreamHandler, handler_types)
+
+    @patch("logging.FileHandler")
+    def test_configure_file_logger(self, mock_file_handler):
+        """
+        Test that the file logger is correctly configured.
+
+        - Uses a mock for FileHandler to avoid creating actual files.
+        - Ensures the logger has at least one handler.
+        - Checks that the log level is set to INFO.
+        - Verifies that FileHandler is called with the correct log file path.
+        """
+        mock_handler_instance = MagicMock()
+        mock_file_handler.return_value = mock_handler_instance
+
+        log_path = "logs/test.log"
+        logger = configure_file_logger(log_path, "TestLogger")
+
+        self.assertTrue(logger.hasHandlers())
+        self.assertEqual(logger.level, logging.INFO)
+        mock_file_handler.assert_called_once_with(log_path)
+
+    def tearDown(self):
+        """
+        Cleanup method executed after each test.
+
+        - Deletes the test log file if it exists.
+        """
+        log_file = "logs/test.log"
+        if os.path.exists(log_file):
+            os.remove(log_file)
+
+
+if __name__ == "__main__":
+    unittest.main()