pyproxytools 0.3.2__py3-none-any.whl

pyproxy/utils/http_req.py

@@ -0,0 +1,53 @@
+"""
+pyproxy.utils.http_req.py
+
+HTTP request parsing utilities for pyproxy.
+"""
+
+
+def extract_headers(request_str):
+    """
+    Extracts the HTTP headers from a raw HTTP request string.
+
+    Args:
+        request_str (str): The full HTTP request as a decoded string.
+
+    Returns:
+        dict: A dictionary containing the HTTP header fields as key-value pairs.
+    """
+    headers = {}
+    lines = request_str.split("\n")[1:]
+    for line in lines:
+        if line.strip():
+            key, value = line.split(":", 1)
+            headers[key.strip()] = value.strip()
+    return headers
+
+
+def parse_url(url):
+    """
+    Parses the URL to extract the host and port for connecting to the target server.
+
+    Args:
+        url (str): The URL to be parsed.
+
+    Returns:
+        tuple: The server host and port.
+    """
+    http_pos = url.find("//")
+    if http_pos != -1:
+        url = url[(http_pos + 2) :]
+    port_pos = url.find(":")
+    path_pos = url.find("/")
+    if path_pos == -1:
+        path_pos = len(url)
+
+    server_host = (
+        url[:path_pos] if port_pos == -1 or port_pos > path_pos else url[:port_pos]
+    )
+    if port_pos == -1 or port_pos > path_pos:
+        server_port = 80
+    else:
+        server_port = int(url[(port_pos + 1) : path_pos])
+
+    return server_host, server_port

pyproxy/utils/logger.py

@@ -0,0 +1,46 @@
+"""
+pyproxy.utils.logger.py
+
+This module contains functions to configure and return loggers for both console and file output.
+"""
+
+import logging
+import os
+
+
+def configure_console_logger() -> logging.Logger:
+    """
+    Configures and returns a logger that outputs log messages to the console.
+
+    Returns:
+        logging.Logger: A logger instance that writes logs to the console.
+    """
+    console_logger = logging.getLogger("ConsoleLogger")
+    console_logger.setLevel(logging.INFO)
+    console_formatter = logging.Formatter(
+        "%(asctime)s - %(message)s", datefmt="%d/%m/%Y %H:%M:%S"
+    )
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(console_formatter)
+    console_logger.addHandler(console_handler)
+    return console_logger
+
+
+def configure_file_logger(log_path: str, name: str) -> logging.Logger:
+    """
+    Configures and returns a logger that writes log messages to a specified file.
+
+    Args:
+        log_path (str): The path where the log file will be created or appended to.
+        name (str): Logger's name.
+
+    Returns:
+        logging.Logger: A logger instance that writes to the specified log file.
+    """
+    os.makedirs(os.path.dirname(log_path), exist_ok=True)
+    file_logger = logging.getLogger(name)
+    file_logger.setLevel(logging.INFO)
+    file_handler = logging.FileHandler(log_path)
+    file_handler.setFormatter(logging.Formatter("%(asctime)s - %(message)s"))
+    file_logger.addHandler(file_handler)
+    return file_logger

pyproxytools-0.3.2.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: pyproxytools
+Version: 0.3.2
+Summary: Lightweight and fast python web proxy
+Author: 6C656C65
+License-Expression: MIT
+Project-URL: Documentation, https://github.com/6C656C65/pyproxy/wiki
+Project-URL: Issue tracker, https://github.com/6C656C65/pyproxy/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich-argparse>=1.7.0
+Requires-Dist: pyOpenSSL>=25.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: Flask>=3.1.0
+Requires-Dist: Flask-HTTPAuth>=4.8.0
+Requires-Dist: psutil>=5.9.8
+Dynamic: license-file
+
+<div align="center">
+  <h1>pyproxy</h1>
+</div>
+
+
+**pyproxy** is a lightweight, fast, and customizable Python-based web proxy server designed to handle both HTTP and HTTPS traffic efficiently. It can be used for various purposes, including web scraping, traffic monitoring, and content filtering.
+
+<p align="center">
+  <img src="https://img.shields.io/github/license/6C656C65/pyproxy?style=for-the-badge">
+  <img src="https://img.shields.io/github/issues/6C656C65/pyproxy?style=for-the-badge">
+  <img src="https://img.shields.io/github/issues-closed/6C656C65/pyproxy?style=for-the-badge">
+  <br>
+  <img src="https://img.shields.io/github/forks/6C656C65/pyproxy?style=for-the-badge">
+  <img src="https://img.shields.io/github/stars/6C656C65/pyproxy?style=for-the-badge">
+  <img src="https://img.shields.io/github/commit-activity/w/6C656C65/pyproxy?style=for-the-badge">
+  <img src="https://img.shields.io/github/contributors/6C656C65/pyproxy?style=for-the-badge">
+  <br>
+  <img src="https://img.shields.io/github/actions/workflow/status/6C656C65/pyproxy/code-scan.yml?label=Scan&style=for-the-badge">
+  <img src="https://img.shields.io/github/actions/workflow/status/6C656C65/pyproxy/unittest.yml?label=Tests&style=for-the-badge">
+  <img src="https://img.shields.io/github/actions/workflow/status/6C656C65/pyproxy/docker-images.yml?label=Delivery&style=for-the-badge">
+</p>
+
+---
+
+## ⚡ **Features**
+
+| Feature                                      | Supported |
+|----------------------------------------------|-----------|
+| HTTP & HTTPS                                 | ✅        |
+| Web request logging                          | ✅        |
+| Domain & URL blacklist                       | ✅        |
+| SSL inspection                               | ✅        |
+| Custom 403 Forbidden page                    | ✅        |
+| Remote (HTTP) blacklist support              | ✅        |
+| Shortcut support                             | ✅        |
+| Disable inspection for banking websites      | ✅        |
+| Custom headers                               | ✅        |
+| Web interface monitoring                     | ✅        |
+| Lightweight Docker image                     | ✅        |
+| Proxy chaining (multi-proxy forwarding)      | ✅        |
+| IP whitelist with subnet support             | ✅        |
+
+## 📦 **Installation**
+
+### Install from source
+```bash
+git clone https://github.com/6C656C65/pyproxy.git
+cd pyproxy
+pip install -r requirements.txt
+```
+
+### Install with Docker
+```bash
+docker pull ghcr.io/6c656c65/pyproxy:latest
+docker run -d ghcr.io/6c656c65/pyproxy:latest
+```
+You can use slim images by adding `-slim` to the end of the tags
+
+## 🚀 **Usage**
+
+### Start the proxy
+```bash
+python3 -m pyproxy.pyproxy
+```
+The proxy will be available at: `0.0.0.0:8080`.
+The access log will be available at `./logs/access.log`.
+
+## 📚 **Documentation**
+If you encounter any problems, or if you want to use the program in a particular way, I advise you to read the [documentation](https://github.com/6C656C65/pyproxy/wiki).
+
+## 🔧 **To do**
+
+- Support content analysis
+- Caching of latest and most searched pages
+
+## 🏎️ **Benchmark**
+
+If you're interested in benchmarking the performance of the proxy or comparing request times with and without a proxy, please refer to the [Benchmark README](benchmark/README.md) for detailed instructions on how to run the benchmarking tests and generate reports.
+
+## 📄 **License**
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🤝 **Contributing**
+
+Contributions are welcome and appreciated! If you'd like to improve this project, feel free to fork the repository and submit a pull request. Whether it's fixing bugs, adding new features, improving documentation, or suggesting enhancements, every bit helps. Please make sure to follow the coding standards and test your changes before submitting. Let's build something great together!
+
+## 📦 Deployment with Ansible
+
+If you want to deploy **pyproxy** automatically to remote servers (via source or Docker), an official [Ansible role](https://github.com/6C656C65/pyproxy_ansible) is available:
+
+* 🔧 Install from source or run as a Docker container
+* 📁 Supports customization of ports, versions, and paths
+* 🚀 Easily integrable into your infrastructure or CI/CD pipelines
+
+👉 Check out the [ansible-role-pyproxy](https://github.com/6C656C65/pyproxy_ansible) repository for more details and usage instructions.
+
+---

pyproxytools-0.3.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+benchmark/benchmark.py,sha256=E_LLmJ1prZ_QghkNUdUOfe87tGxOxqdn-z49LFtniQY,5427
+benchmark/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+benchmark/utils/html.py,sha256=PpEv92f0b2rhK_Pcu2019Vkn7Q0XMka_ai4PQic7__s,5460
+benchmark/utils/req.py,sha256=85b59kCtY6dXigahXcNmZXxbOshvNuBYxRTVJGQKPNQ,1200
+pyproxy/__init__.py,sha256=CMJC6v1rgmB-ZhMt-5gbBt0wMc7MS4pkhSzF3ZuMM-U,270
+pyproxy/pyproxy.py,sha256=sJGxPIYnnn-hR9COvcBpjED8rruCYfa30PHfBPwVmus,4124
+pyproxy/server.py,sha256=xA-RHd6FNWJB4Jr1pZzJbPcmC4ioezWqCJcf_jMm6XE,12437
+pyproxy/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyproxy/handlers/client.py,sha256=PYttEu7Y0quDw1L0vHlkUmsJHVTzimiF5Qw82TzjDTo,5148
+pyproxy/handlers/http.py,sha256=egz88l7Lnr_w1HYPKQuK727rALYHPpy6ilgZFKZBIJo,7623
+pyproxy/handlers/https.py,sha256=ysv1uYrJLgJMyMr7luqgCKPXGhUq1hpDESVb3cHp9aE,12879
+pyproxy/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyproxy/modules/cancel_inspect.py,sha256=OyyOLsgyGfesIV8QlhtB_z1Gw0aZlQI1opLjF_konKI,2615
+pyproxy/modules/custom_header.py,sha256=tjqvZ1FPnEIbQRhvy1YYANzQyTbkn0zKOK_83h6Sf6E,2513
+pyproxy/modules/filter.py,sha256=2S_tQcyfBB-O741Q2zTnrg9IudIkKjzHIbsLMYU6j20,5111
+pyproxy/modules/shortcuts.py,sha256=7qw0veqn5WCy0iOsNlg-p6hhUyGnTnz6ZIORfPvZvtg,2557
+pyproxy/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyproxy/monitoring/web.py,sha256=DTszt48G7sXpCqCetHAb2EI-1wauRxG-Og1sSRUEiug,9966
+pyproxy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyproxy/utils/args.py,sha256=8LNJa5hwtQrVo3V3bT_eqzYg43_8I78X885zVEV-T1M,5884
+pyproxy/utils/config.py,sha256=amTSmoD5WH0JSoArLvMiG6BFvN_c5bgXbABLbPWAEPk,3283
+pyproxy/utils/crypto.py,sha256=eEEL9sujn4P4gY5_VIbarXyGk_wESjUov2l8-UN6Bo0,1672
+pyproxy/utils/http_req.py,sha256=fA-L2RJwdMHXAcVNEvD3I_r1jpPZVx74S8ZSeVzXJUA,1301
+pyproxy/utils/logger.py,sha256=VHQa4GmcmH_Dp2uBq2_kd8xOnHmSCxOtsGkNTthCBDQ,1500
+pyproxy/utils/version.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyproxytools-0.3.2.dist-info/licenses/LICENSE,sha256=TDdWrw5utS7dNRdzxWj_1RM54vnlX0lYzL-GS82pIhA,1065
+tests/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/modules/test_cancel_inspect.py,sha256=JRIf8TvDS8NCFY_HCX7fuNbhfHDqnVCoT2ZuvBNuZho,2123
+tests/modules/test_custom_header.py,sha256=CmBJIjIvAgTfEdeNivrxxDbWrOCM4n9J8PNndhKER50,2272
+tests/modules/test_filter.py,sha256=6sNG1IYtmsxnIUvhobRQAVFPN-O-CTWEiMuRsX2BqZ8,7078
+tests/modules/test_shortcuts.py,sha256=Ly717FJX-Xc2DYzLyoKvJkqr7PDpPRAgt2yyPeR2-So,4513
+tests/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/utils/test_crypto.py,sha256=7WKd3Ots9QjcWKj_AM93kNNB4ODZGwZ8pxryiQT5w94,3668
+tests/utils/test_http_req.py,sha256=E0hGMHmhAk0nar70sL9XvGY2H2U_t7f8rdVALwXFurI,1971
+tests/utils/test_logger.py,sha256=OkH68HzIJuIMPQN-webzdGjNUMeg6Qu-mWVk-hhzrA8,2139
+pyproxytools-0.3.2.dist-info/METADATA,sha256=r_gYxlruCMLllAnHwDrRD_1irryodL_Yw62inwf1G6U,5729
+pyproxytools-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyproxytools-0.3.2.dist-info/entry_points.txt,sha256=qr3JIpFvNnWEJAkr6krRZDC2paiG_P_VlIQ6QmTHZ88,49
+pyproxytools-0.3.2.dist-info/top_level.txt,sha256=QSDF6at2BiAjnYt-WyhDBCDUzlzn_lzOAwQ4v3H5ZVE,24
+pyproxytools-0.3.2.dist-info/RECORD,,

pyproxytools-0.3.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyproxytools-0.3.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyproxy = pyproxy.pyproxy:main

pyproxytools-0.3.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 6C656C65
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyproxytools-0.3.2.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+benchmark
+pyproxy
+tests

tests/modules/test_cancel_inspect.py

@@ -0,0 +1,67 @@
+"""
+test_cancel_inspection.py
+
+This test module verifies the functionality of the `cancel_inspection.py` module.
+
+Tests:
+- test_load_cancel_inspect: Ensures entries are correctly loaded from a test file.
+- test_cancel_inspect_process: Validates the multiprocessing behavior of
+                checking cancel inspection entries.
+"""
+
+import unittest
+import tempfile
+import os
+import multiprocessing
+import time
+
+from pyproxy.modules.cancel_inspect import load_cancel_inspect, cancel_inspect_process
+
+
+class TestCancelInspect(unittest.TestCase):
+    """Unit tests for the cancel_inspection.py module."""
+
+    def setUp(self):
+        """Set up a temporary file with test data for cancel inspection."""
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w+", delete=False)
+        self.temp_file.write("http://example.com/1\nhttp://example.com/2\n")
+        self.temp_file.close()
+        self.path = self.temp_file.name
+
+    def tearDown(self):
+        """Remove the temporary file after tests complete."""
+        os.unlink(self.path)
+
+    def test_load_cancel_inspect(self):
+        """Test that the cancel inspection file is correctly loaded into a list."""
+        entries = load_cancel_inspect(self.path)
+        self.assertEqual(len(entries), 2)
+        self.assertIn("http://example.com/1\n", entries)
+        self.assertIn("http://example.com/2\n", entries)
+
+    def test_cancel_inspect_process(self):
+        """Test that the cancel inspection process returns the correct match result."""
+        queue = multiprocessing.Queue()
+        result_queue = multiprocessing.Queue()
+
+        process = multiprocessing.Process(
+            target=cancel_inspect_process, args=(queue, result_queue, self.path)
+        )
+        process.start()
+
+        time.sleep(1)
+
+        queue.put("http://example.com/1\n")
+        result = result_queue.get(timeout=3)
+        self.assertTrue(result)
+
+        queue.put("http://nonexistent.com/\n")
+        result = result_queue.get(timeout=3)
+        self.assertFalse(result)
+
+        process.terminate()
+        process.join()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/modules/test_custom_header.py

@@ -0,0 +1,70 @@
+"""
+test_custom_header.py
+
+This test module verifies the functionality of the `custom_header.py` module.
+
+Tests:
+- test_load_custom_header: Ensures JSON headers are correctly loaded from a test file.
+- test_custom_header_process: Validates the multiprocessing behavior of resolving custom headers.
+"""
+
+import unittest
+import tempfile
+import os
+import multiprocessing
+import time
+import json
+
+from pyproxy.modules.custom_header import load_custom_header, custom_header_process
+
+
+class TestCustomHeader(unittest.TestCase):
+    """Unit tests for the custom_header.py module."""
+
+    def setUp(self):
+        """Set up a temporary JSON file with test data for custom headers."""
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w+", delete=False)
+        self.sample_data = {
+            "http://example.com": {"X-Test-Header": "123", "X-Another": "456"},
+            "http://another.com": {"X-Custom": "abc"},
+        }
+        json.dump(self.sample_data, self.temp_file)
+        self.temp_file.close()
+        self.path = self.temp_file.name
+
+    def tearDown(self):
+        """Remove the temporary file after tests complete."""
+        os.unlink(self.path)
+
+    def test_load_custom_header(self):
+        """Test that the custom header JSON file is correctly loaded into a dictionary."""
+        headers = load_custom_header(self.path)
+        self.assertEqual(headers["http://example.com"]["X-Test-Header"], "123")
+        self.assertIn("http://another.com", headers)
+
+    def test_custom_header_process(self):
+        """Test that the custom header process returns the correct header dictionary."""
+        queue = multiprocessing.Queue()
+        result_queue = multiprocessing.Queue()
+
+        process = multiprocessing.Process(
+            target=custom_header_process, args=(queue, result_queue, self.path)
+        )
+        process.start()
+
+        time.sleep(1)
+
+        queue.put("http://example.com")
+        result = result_queue.get(timeout=3)
+        self.assertEqual(result, {"X-Test-Header": "123", "X-Another": "456"})
+
+        queue.put("http://nonexistent.com")
+        result = result_queue.get(timeout=3)
+        self.assertEqual(result, {})
+
+        process.terminate()
+        process.join()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/modules/test_filter.py

@@ -0,0 +1,185 @@
+"""
+test_filter.py
+
+This module contains unit tests for the `filter.py` module.
+It verifies the correct functionality of loading blacklists and filtering domains/URLs.
+
+Tested Functions:
+- load_blacklist: Ensures that the blacklist is correctly loaded from the file.
+- filter_process: Ensures that domains/URLs are correctly filtered based on the blacklist.
+
+Test Cases:
+- TestLoadBlacklist: Checks the correct loading of blocked sites and URLs from the file.
+- TestFilterProcess: Verifies that domains/URLs are correctly identified as blocked or allowed.
+- TestLoadBlacklistFileNotFound: Verifies that a FileNotFoundError is
+                raised when the blacklist file is missing.
+- TestLoadBlacklistHttpError: Verifies that an HTTP error is handled
+                correctly when loading blacklists.
+- TestLoadBlacklistEmptyFile: Verifies that an empty file returns empty
+                sets for blocked sites and URLs.
+- TestFilterProcessWithPathAndPort: Verifies that URLs with paths or ports are correctly filtered.
+"""
+
+import unittest
+import multiprocessing
+from unittest.mock import patch, mock_open
+import requests
+from pyproxy.modules.filter import load_blacklist, filter_process
+
+
+class TestFilter(unittest.TestCase):
+    """
+    Test suite for the filter 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_blacklist(self):
+        """Tests if the blacklist is correctly loaded from the file."""
+        with patch(
+            "builtins.open",
+            new_callable=mock_open,
+            read_data="blocked.com\nallowed.com/blocked",
+        ):
+            blocked_sites, blocked_urls = load_blacklist(
+                "blocked_sites.txt", "blocked_urls.txt", "local"
+            )
+            self.assertIn("blocked.com", blocked_sites)
+            self.assertIn("allowed.com/blocked", blocked_sites)
+            self.assertIsInstance(blocked_sites, set)
+            self.assertIsInstance(blocked_urls, set)
+
+    @patch("builtins.open", side_effect=FileNotFoundError("File not found"))
+    def test_load_blacklist_file_not_found(self, _mock_file):
+        """Tests that a FileNotFoundError is raised when the blacklist file is missing."""
+        with self.assertRaises(FileNotFoundError):
+            load_blacklist("invalid_file.txt", "blocked_urls.txt", "local")
+
+    @patch(
+        "requests.get",
+        side_effect=requests.exceptions.RequestException("Failed to load"),
+    )
+    def test_load_blacklist_http_error(self, _mock_request):
+        """Tests that an HTTP error is handled correctly when loading blacklists."""
+        with self.assertRaises(requests.exceptions.RequestException):
+            load_blacklist(
+                "http://example.com/blocked_sites",
+                "http://example.com/blocked_urls",
+                "http",
+            )
+
+    @patch("builtins.open", new_callable=mock_open, read_data="")
+    def test_load_blacklist_empty_file(self, _mock_file):
+        """Tests that an empty file returns empty sets for blocked sites and URLs."""
+        blocked_sites, blocked_urls = load_blacklist(
+            "empty_sites.txt", "empty_urls.txt", "local"
+        )
+        self.assertEqual(len(blocked_sites), 0)
+        self.assertEqual(len(blocked_urls), 0)
+
+    def _test_filter_process_helper(
+        self,
+        input_urls,
+        expected_results,
+        patch_data="blocked.com\nallowed.com/blocked",
+    ):
+        """Helper method to test filter_process with different inputs."""
+        with patch("builtins.open", new_callable=mock_open, read_data=patch_data):
+            process = multiprocessing.Process(
+                target=filter_process,
+                args=(
+                    self.queue,
+                    self.result_queue,
+                    "local",
+                    "blocked_sites.txt",
+                    "blocked_urls.txt",
+                ),
+            )
+            process.start()
+
+            for url in input_urls:
+                self.queue.put(url)
+
+            results = []
+            for _ in expected_results:
+                results.append(self.result_queue.get(timeout=2))
+
+            self.assertEqual(results, expected_results)
+            process.terminate()
+            process.join()
+
+    def test_filter_process(self):
+        """Tests if domains/URLs are correctly identified as blocked or allowed."""
+        input_urls = [
+            "http://blocked.com/",
+            "http://allowed.com/",
+            "http://allowed.com/blocked",
+            "http://allowed.com/allowed",
+        ]
+        expected_results = [
+            ("blocked.com", "Blocked"),
+            ("allowed.com", "Allowed"),
+            ("allowed.com/blocked", "Blocked"),
+            ("allowed.com", "Allowed"),
+        ]
+        self._test_filter_process_helper(input_urls, expected_results)
+
+    def test_filter_process_with_query_string(self):
+        """Tests if URLs with query strings are correctly filtered."""
+        input_urls = [
+            "http://blocked.com?tracking=123",
+            "http://example.com/secret?auth=false",
+            "http://safe.com/page?debug=true",
+        ]
+        expected_results = [
+            ("blocked.com", "Blocked"),
+            ("example.com/secret", "Blocked"),
+            ("safe.com", "Allowed"),
+        ]
+        self._test_filter_process_helper(
+            input_urls, expected_results, patch_data="blocked.com\nexample.com/secret"
+        )
+
+    def test_filter_process_subdomain_not_blocked(self):
+        """
+        Tests if subdomains are correctly handled and not blocked if the main domain is not blocked.
+        """
+        input_urls = ["http://sub.blocked.com/"]
+        expected_results = [("sub.blocked.com", "Allowed")]
+        self._test_filter_process_helper(
+            input_urls, expected_results, patch_data="blocked.com\n"
+        )
+
+    def test_filter_process_special_characters(self):
+        """Tests if URLs with special characters are correctly handled."""
+        input_urls = ["http://weird-site.com/"]
+        expected_results = [("weird-site.com", "Blocked")]
+        self._test_filter_process_helper(
+            input_urls, expected_results, patch_data="weird-site.com\n"
+        )
+
+    def test_filter_process_with_path_and_port(self):
+        """Tests if URLs with paths and ports are correctly filtered."""
+        input_urls = [
+            "http://blocked.com:8080/path/to/resource",
+            "http://allowed.com/blocked/resource",
+        ]
+        expected_results = [
+            ("blocked.com", "Blocked"),
+            ("allowed.com/blocked/resource", "Blocked"),
+        ]
+        self._test_filter_process_helper(input_urls, expected_results)
+
+
+if __name__ == "__main__":
+    unittest.main()