argus-guard 0.1.0a1__tar.gz

argus_guard-0.1.0a1/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Irena Popova
+
+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.

argus_guard-0.1.0a1/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: argus-guard
+Version: 0.1.0a1
+Summary: Modular cybersecurity auditing, DevSecOps verification, and monitoring toolkit.
+Author: Irena Popova
+License-Expression: MIT
+Keywords: cybersecurity,security,security-auditing,devsecops,monitoring,automation,python,rust
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ARGUS Security
+
+### Modular Cybersecurity Analysis, Auditing & Monitoring
+
+**ARGUS Security** is a modular cybersecurity toolkit under development, built with **Python and Rust**.
+
+The project aims to combine security analysis algorithms, automated verification, system diagnostics, and monitoring within a flexible, extensible architecture.
+
+ARGUS is designed to support both command-line usage and future web-based security assessment services.
+
+## Project Objectives
+
+- Develop modular algorithms for security analysis and auditing.
+- Automate reproducible security verification workflows.
+- Identify potential vulnerabilities and configuration weaknesses.
+- Support structured security assessments and reporting.
+- Integrate system monitoring and operational diagnostics.
+- Provide an extensible architecture for additional security modules.
+
+## Technology Stack
+
+| Technology | Purpose |
+|---|---|
+| Python | Security analysis, automation, orchestration, and reporting |
+| Rust | Performance-sensitive and memory-safe system components |
+| Docker | Containerization and reproducible deployment |
+| Prometheus | Metrics collection and monitoring |
+| Grafana | Monitoring dashboards and visualization |
+| GitHub Actions | Continuous integration and automated testing |
+
+## Architecture
+
+ARGUS follows a modular architecture based on independent security analysis components.
+
+**Python Layer**
+
+- Security analysis algorithms
+- Workflow orchestration
+- Configuration validation
+- Data processing
+- Report generation
+- Command-line interfaces
+
+**Rust Layer**
+
+- Performance-critical operations
+- Low-level system utilities
+- Efficient data processing
+- Security-focused components
+
+**Monitoring & Infrastructure**
+
+- Docker-based environments
+- Prometheus metrics
+- Grafana dashboards
+- Automated testing and deployment workflows
+
+## Planned Interfaces
+
+**1. Command-Line Toolkit**
+
+A locally installable toolkit for developers, security engineers, and system administrators.
+
+**2. Web-Based Security Assessment**
+
+A future interface for submitting authorized targets, executing supported security checks, and reviewing structured reports.
+
+**3. Modular Integration**
+
+Reusable components that can be integrated into other software systems and security workflows.
+
+## Development Roadmap
+
+- [ ] Establish Python and Rust project structure
+- [ ] Implement initial security analysis algorithms
+- [ ] Build a modular execution and orchestration framework
+- [ ] Develop command-line interfaces
+- [ ] Implement structured security reporting
+- [ ] Integrate Python and Rust components
+- [ ] Add Docker support
+- [ ] Integrate Prometheus and Grafana
+- [ ] Configure automated testing and CI workflows
+- [ ] Develop an optional web interface
+
+## Development Status
+
+🚧 **Early development — architecture and core components are being established.**
+
+Features listed in the roadmap are planned and should not be considered implemented or production-ready.
+
+## Security & Responsible Use
+
+ARGUS Security is intended for legitimate security research, defensive analysis, and authorized security assessments.
+
+Users must obtain appropriate permission before examining systems, networks, or services they do not own or administer.
+
+## Author
+
+**Irena Popova**
+
+Software Developer | Independent Researcher
+
+Background in applied linguistics, computer science, software development, and computational research.
+
+GitHub: [@irenapopova](https://github.com/irenapopova)
+
+---
+
+**ARGUS Security — Engineering security through algorithms, verification, and evidence.**

argus_guard-0.1.0a1/README.md

@@ -0,0 +1,109 @@
+# ARGUS Security
+
+### Modular Cybersecurity Analysis, Auditing & Monitoring
+
+**ARGUS Security** is a modular cybersecurity toolkit under development, built with **Python and Rust**.
+
+The project aims to combine security analysis algorithms, automated verification, system diagnostics, and monitoring within a flexible, extensible architecture.
+
+ARGUS is designed to support both command-line usage and future web-based security assessment services.
+
+## Project Objectives
+
+- Develop modular algorithms for security analysis and auditing.
+- Automate reproducible security verification workflows.
+- Identify potential vulnerabilities and configuration weaknesses.
+- Support structured security assessments and reporting.
+- Integrate system monitoring and operational diagnostics.
+- Provide an extensible architecture for additional security modules.
+
+## Technology Stack
+
+| Technology | Purpose |
+|---|---|
+| Python | Security analysis, automation, orchestration, and reporting |
+| Rust | Performance-sensitive and memory-safe system components |
+| Docker | Containerization and reproducible deployment |
+| Prometheus | Metrics collection and monitoring |
+| Grafana | Monitoring dashboards and visualization |
+| GitHub Actions | Continuous integration and automated testing |
+
+## Architecture
+
+ARGUS follows a modular architecture based on independent security analysis components.
+
+**Python Layer**
+
+- Security analysis algorithms
+- Workflow orchestration
+- Configuration validation
+- Data processing
+- Report generation
+- Command-line interfaces
+
+**Rust Layer**
+
+- Performance-critical operations
+- Low-level system utilities
+- Efficient data processing
+- Security-focused components
+
+**Monitoring & Infrastructure**
+
+- Docker-based environments
+- Prometheus metrics
+- Grafana dashboards
+- Automated testing and deployment workflows
+
+## Planned Interfaces
+
+**1. Command-Line Toolkit**
+
+A locally installable toolkit for developers, security engineers, and system administrators.
+
+**2. Web-Based Security Assessment**
+
+A future interface for submitting authorized targets, executing supported security checks, and reviewing structured reports.
+
+**3. Modular Integration**
+
+Reusable components that can be integrated into other software systems and security workflows.
+
+## Development Roadmap
+
+- [ ] Establish Python and Rust project structure
+- [ ] Implement initial security analysis algorithms
+- [ ] Build a modular execution and orchestration framework
+- [ ] Develop command-line interfaces
+- [ ] Implement structured security reporting
+- [ ] Integrate Python and Rust components
+- [ ] Add Docker support
+- [ ] Integrate Prometheus and Grafana
+- [ ] Configure automated testing and CI workflows
+- [ ] Develop an optional web interface
+
+## Development Status
+
+🚧 **Early development — architecture and core components are being established.**
+
+Features listed in the roadmap are planned and should not be considered implemented or production-ready.
+
+## Security & Responsible Use
+
+ARGUS Security is intended for legitimate security research, defensive analysis, and authorized security assessments.
+
+Users must obtain appropriate permission before examining systems, networks, or services they do not own or administer.
+
+## Author
+
+**Irena Popova**
+
+Software Developer | Independent Researcher
+
+Background in applied linguistics, computer science, software development, and computational research.
+
+GitHub: [@irenapopova](https://github.com/irenapopova)
+
+---
+
+**ARGUS Security — Engineering security through algorithms, verification, and evidence.**

argus_guard-0.1.0a1/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=77.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "argus-guard"
+version = "0.1.0a1"
+
+description = "Modular cybersecurity auditing, DevSecOps verification, and monitoring toolkit."
+
+readme = "README.md"
+requires-python = ">=3.11"
+
+license = "MIT"
+license-files = ["LICENSE"]
+
+authors = [
+    { name = "Irena Popova" }
+]
+
+keywords = [
+    "cybersecurity",
+    "security",
+    "security-auditing",
+    "devsecops",
+    "monitoring",
+    "automation",
+    "python",
+    "rust"
+]
+
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Security"
+]
+
+dependencies = []
+
+[tool.setuptools]
+package-dir = { "" = "python/src" }
+
+[tool.setuptools.packages.find]
+where = ["python/src"]
+include = ["argus_guard*"]
+namespaces = false
+
+[project.scripts]
+argus-guard = "argus_guard.cli:main"

argus_guard-0.1.0a1/python/src/argus_guard/__init__.py

@@ -0,0 +1,20 @@
+"""
+ARGUS
+=====
+
+Modular Cybersecurity Analysis, Automated Auditing,
+DevSecOps and Monitoring.
+
+Built with Python and Rust.
+
+Author: Irena Popova
+License: MIT
+"""
+
+__version__ = "0.1.0a1"
+__author__ = "Irena Popova"
+
+__all__ = [
+    "__version__",
+    "__author__",
+]

argus_guard-0.1.0a1/python/src/argus_guard/cli.py

@@ -0,0 +1,138 @@
+"""
+ARGUS — Command-Line Interface
+==============================
+
+Command-line interface for cybersecurity analysis,
+automated auditing, and diagnostic reporting.
+
+Author: Irena Popova
+License: MIT
+"""
+
+import argparse
+import json
+import sys
+
+from .http_client import (
+    fetch_response_headers,
+    HeaderFetchError,
+)
+
+from .security_headers import (
+    audit_security_headers,
+    calculate_header_coverage,
+)
+
+
+def run_headers_audit(
+    url: str,
+    json_output: bool = False,
+) -> dict:
+    """
+    Execute an HTTP security headers audit.
+
+    Args:
+        url: Authorized HTTPS target.
+        json_output: Whether to print JSON output.
+
+    Returns:
+        Dictionary containing the audit results.
+    """
+
+    headers = fetch_response_headers(url)
+
+    results = audit_security_headers(headers)
+
+    coverage = calculate_header_coverage(results)
+
+    report = {
+        "target": url,
+        "checks": results,
+        "header_coverage_percent": coverage,
+    }
+
+    if json_output:
+        print(json.dumps(report, indent=2))
+
+    else:
+        print("\nARGUS — Security Headers Audit")
+        print("=" * 40)
+
+        print(f"Target: {url}\n")
+
+        for header, present in results.items():
+            status = "PRESENT" if present else "MISSING"
+            print(f"[{status}] {header}")
+
+        print(f"\nHeader coverage: {coverage}%")
+
+        print(
+            "\nNote: Header presence does not guarantee "
+            "a secure configuration."
+        )
+
+    return report
+
+
+def main() -> int:
+    """Entry point for the ARGUS command-line interface."""
+
+    parser = argparse.ArgumentParser(
+        prog="argus-guard",
+        description=(
+            "ARGUS — Modular Cybersecurity Auditing Toolkit"
+        ),
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+
+    headers_parser = subparsers.add_parser(
+        "headers",
+        help="Audit HTTP security headers",
+    )
+
+    headers_parser.add_argument(
+        "url",
+        help="HTTPS URL you are authorized to audit",
+    )
+
+    headers_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results in JSON format",
+    )
+
+    headers_parser.add_argument(
+        "--fail-on-missing",
+        action="store_true",
+        help="Return exit code 1 if any checked header is missing",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "headers":
+
+        try:
+            report = run_headers_audit(
+                args.url,
+                json_output=args.json,
+            )
+
+        except (HeaderFetchError, ValueError) as error:
+            print(f"ARGUS error: {error}", file=sys.stderr)
+            return 2
+
+        if args.fail_on_missing:
+            if not all(report["checks"].values()):
+                return 1
+
+        return 0
+
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

argus_guard-0.1.0a1/python/src/argus_guard/http_client.py

@@ -0,0 +1,90 @@
+"""
+ARGUS — HTTP Client
+===================
+
+Retrieves HTTP response headers for security analysis.
+
+Designed for authorized security auditing.
+
+Author: Irena Popova
+License: MIT
+"""
+
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit
+from urllib.request import (
+    Request,
+    HTTPRedirectHandler,
+    build_opener,
+)
+
+
+class HeaderFetchError(RuntimeError):
+    """Raised when HTTP response headers cannot be retrieved."""
+
+
+class NoRedirectHandler(HTTPRedirectHandler):
+    """Prevent automatic HTTP redirects."""
+
+    def redirect_request(
+        self, request, fp, code, message, headers, new_url
+    ):
+        return None
+
+
+def fetch_response_headers(
+    url: str,
+    timeout: float = 10.0,
+) -> dict[str, str]:
+    """
+    Retrieve HTTP response headers from an HTTPS URL.
+
+    Args:
+        url: Target HTTPS URL.
+        timeout: Connection timeout in seconds.
+
+    Returns:
+        Dictionary containing HTTP response headers.
+
+    Raises:
+        ValueError: If the URL or timeout is invalid.
+        HeaderFetchError: If the request fails.
+    """
+
+    parsed_url = urlsplit(url)
+
+    if parsed_url.scheme.lower() != "https":
+        raise ValueError("Only HTTPS URLs are supported.")
+
+    if not parsed_url.hostname:
+        raise ValueError("A valid hostname is required.")
+
+    if parsed_url.username or parsed_url.password:
+        raise ValueError("URLs containing credentials are not supported.")
+
+    if timeout <= 0:
+        raise ValueError("Timeout must be greater than zero.")
+
+    request = Request(
+        url,
+        headers={
+            "User-Agent": "ARGUS-Guard/0.1.0a1",
+        },
+        method="GET",
+    )
+
+    opener = build_opener(NoRedirectHandler())
+
+    try:
+        with opener.open(request, timeout=timeout) as response:
+            return dict(response.headers.items())
+
+    except HTTPError as error:
+        raise HeaderFetchError(
+            f"HTTP request failed with status {error.code}"
+        ) from error
+
+    except (URLError, TimeoutError) as error:
+        raise HeaderFetchError(
+            f"Unable to retrieve headers: {error}"
+        ) from error

argus_guard-0.1.0a1/python/src/argus_guard/security_headers.py

@@ -0,0 +1,68 @@
+"""
+ARGUS — HTTP Security Headers Analysis
+======================================
+
+Provides deterministic checks for the presence of
+recommended HTTP security headers.
+
+Author: Irena Popova
+License: MIT
+"""
+
+from collections.abc import Mapping
+
+
+SECURITY_HEADERS = {
+    "strict-transport-security": "HTTP Strict Transport Security",
+    "content-security-policy": "Content Security Policy",
+    "x-content-type-options": "MIME Type Protection",
+    "referrer-policy": "Referrer Policy",
+}
+
+
+def audit_security_headers(
+    headers: Mapping[str, str],
+) -> dict[str, bool]:
+    """
+    Check the presence of recommended HTTP security headers.
+
+    Args:
+        headers: HTTP response headers.
+
+    Returns:
+        Dictionary containing the result for each header.
+        True means present; False means missing.
+    """
+
+    normalized_headers = {
+        name.lower(): value.strip()
+        for name, value in headers.items()
+    }
+
+    results = {}
+
+    for header in SECURITY_HEADERS:
+        results[header] = bool(
+            normalized_headers.get(header)
+        )
+
+    return results
+
+
+def calculate_header_coverage(
+    results: Mapping[str, bool],
+) -> float:
+    """
+    Calculate the percentage of checked headers present.
+
+    This is a header coverage metric,
+    not an overall cybersecurity score.
+    """
+
+    if not results:
+        return 0.0
+
+    present = sum(results.values())
+    total = len(results)
+
+    return round((present / total) * 100, 2)

argus_guard-0.1.0a1/python/src/argus_guard.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: argus-guard
+Version: 0.1.0a1
+Summary: Modular cybersecurity auditing, DevSecOps verification, and monitoring toolkit.
+Author: Irena Popova
+License-Expression: MIT
+Keywords: cybersecurity,security,security-auditing,devsecops,monitoring,automation,python,rust
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ARGUS Security
+
+### Modular Cybersecurity Analysis, Auditing & Monitoring
+
+**ARGUS Security** is a modular cybersecurity toolkit under development, built with **Python and Rust**.
+
+The project aims to combine security analysis algorithms, automated verification, system diagnostics, and monitoring within a flexible, extensible architecture.
+
+ARGUS is designed to support both command-line usage and future web-based security assessment services.
+
+## Project Objectives
+
+- Develop modular algorithms for security analysis and auditing.
+- Automate reproducible security verification workflows.
+- Identify potential vulnerabilities and configuration weaknesses.
+- Support structured security assessments and reporting.
+- Integrate system monitoring and operational diagnostics.
+- Provide an extensible architecture for additional security modules.
+
+## Technology Stack
+
+| Technology | Purpose |
+|---|---|
+| Python | Security analysis, automation, orchestration, and reporting |
+| Rust | Performance-sensitive and memory-safe system components |
+| Docker | Containerization and reproducible deployment |
+| Prometheus | Metrics collection and monitoring |
+| Grafana | Monitoring dashboards and visualization |
+| GitHub Actions | Continuous integration and automated testing |
+
+## Architecture
+
+ARGUS follows a modular architecture based on independent security analysis components.
+
+**Python Layer**
+
+- Security analysis algorithms
+- Workflow orchestration
+- Configuration validation
+- Data processing
+- Report generation
+- Command-line interfaces
+
+**Rust Layer**
+
+- Performance-critical operations
+- Low-level system utilities
+- Efficient data processing
+- Security-focused components
+
+**Monitoring & Infrastructure**
+
+- Docker-based environments
+- Prometheus metrics
+- Grafana dashboards
+- Automated testing and deployment workflows
+
+## Planned Interfaces
+
+**1. Command-Line Toolkit**
+
+A locally installable toolkit for developers, security engineers, and system administrators.
+
+**2. Web-Based Security Assessment**
+
+A future interface for submitting authorized targets, executing supported security checks, and reviewing structured reports.
+
+**3. Modular Integration**
+
+Reusable components that can be integrated into other software systems and security workflows.
+
+## Development Roadmap
+
+- [ ] Establish Python and Rust project structure
+- [ ] Implement initial security analysis algorithms
+- [ ] Build a modular execution and orchestration framework
+- [ ] Develop command-line interfaces
+- [ ] Implement structured security reporting
+- [ ] Integrate Python and Rust components
+- [ ] Add Docker support
+- [ ] Integrate Prometheus and Grafana
+- [ ] Configure automated testing and CI workflows
+- [ ] Develop an optional web interface
+
+## Development Status
+
+🚧 **Early development — architecture and core components are being established.**
+
+Features listed in the roadmap are planned and should not be considered implemented or production-ready.
+
+## Security & Responsible Use
+
+ARGUS Security is intended for legitimate security research, defensive analysis, and authorized security assessments.
+
+Users must obtain appropriate permission before examining systems, networks, or services they do not own or administer.
+
+## Author
+
+**Irena Popova**
+
+Software Developer | Independent Researcher
+
+Background in applied linguistics, computer science, software development, and computational research.
+
+GitHub: [@irenapopova](https://github.com/irenapopova)
+
+---
+
+**ARGUS Security — Engineering security through algorithms, verification, and evidence.**

argus_guard-0.1.0a1/python/src/argus_guard.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+python/src/argus_guard/__init__.py
+python/src/argus_guard/cli.py
+python/src/argus_guard/http_client.py
+python/src/argus_guard/security_headers.py
+python/src/argus_guard.egg-info/PKG-INFO
+python/src/argus_guard.egg-info/SOURCES.txt
+python/src/argus_guard.egg-info/dependency_links.txt
+python/src/argus_guard.egg-info/entry_points.txt
+python/src/argus_guard.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_http_client.py
+tests/test_security_headers.py

argus_guard-0.1.0a1/python/src/argus_guard.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

argus_guard-0.1.0a1/python/src/argus_guard.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+argus-guard = argus_guard.cli:main

argus_guard-0.1.0a1/python/src/argus_guard.egg-info/top_level.txt

@@ -0,0 +1 @@
+argus_guard

argus_guard-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

argus_guard-0.1.0a1/tests/test_cli.py

@@ -0,0 +1,94 @@
+import io
+import json
+import unittest
+
+from contextlib import redirect_stdout, redirect_stderr
+from unittest.mock import patch
+
+from argus_guard.cli import main
+
+
+class TestARGUSCLI(unittest.TestCase):
+
+    @patch("argus_guard.cli.fetch_response_headers")
+    def test_json_output(self, mock_fetch):
+        mock_fetch.return_value = {
+            "Strict-Transport-Security": "max-age=31536000",
+            "X-Content-Type-Options": "nosniff",
+            "Referrer-Policy": "strict-origin",
+        }
+
+        output = io.StringIO()
+
+        with patch(
+            "sys.argv",
+            [
+                "argus-guard",
+                "headers",
+                "https://example.com",
+                "--json",
+            ],
+        ):
+            with redirect_stdout(output):
+                exit_code = main()
+
+        report = json.loads(output.getvalue())
+
+        self.assertEqual(exit_code, 0)
+
+        self.assertEqual(
+            report["target"],
+            "https://example.com",
+        )
+
+        self.assertEqual(
+            report["header_coverage_percent"],
+            75.0,
+        )
+
+        self.assertFalse(
+            report["checks"]["content-security-policy"]
+        )
+
+    @patch("argus_guard.cli.fetch_response_headers")
+    def test_fail_on_missing_header(self, mock_fetch):
+        mock_fetch.return_value = {
+            "Strict-Transport-Security": "max-age=31536000",
+        }
+
+        with patch(
+            "sys.argv",
+            [
+                "argus-guard",
+                "headers",
+                "https://example.com",
+                "--fail-on-missing",
+            ],
+        ):
+            with redirect_stdout(io.StringIO()):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 1)
+
+    @patch("argus_guard.cli.fetch_response_headers")
+    def test_invalid_url_returns_error(self, mock_fetch):
+        mock_fetch.side_effect = ValueError(
+            "Only HTTPS URLs are supported."
+        )
+
+        with patch(
+            "sys.argv",
+            [
+                "argus-guard",
+                "headers",
+                "http://example.com",
+            ],
+        ):
+            with redirect_stderr(io.StringIO()):
+                exit_code = main()
+
+        self.assertEqual(exit_code, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

argus_guard-0.1.0a1/tests/test_http_client.py

@@ -0,0 +1,70 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from urllib.error import URLError
+
+from argus_guard.http_client import (
+    HeaderFetchError,
+    fetch_response_headers,
+)
+
+
+class TestHTTPClient(unittest.TestCase):
+
+    def test_rejects_http_urls(self):
+        with self.assertRaises(ValueError):
+            fetch_response_headers("http://example.com")
+
+    def test_rejects_urls_with_credentials(self):
+        with self.assertRaises(ValueError):
+            fetch_response_headers(
+                "https://user:password@example.com"
+            )
+
+    def test_rejects_invalid_timeout(self):
+        with self.assertRaises(ValueError):
+            fetch_response_headers(
+                "https://example.com",
+                timeout=0,
+            )
+
+    @patch("argus_guard.http_client.build_opener")
+    def test_fetches_response_headers(self, mock_build_opener):
+        response = MagicMock()
+
+        response.headers.items.return_value = [
+            ("Strict-Transport-Security", "max-age=31536000"),
+            ("Content-Security-Policy", "default-src 'self'"),
+        ]
+
+        response.__enter__.return_value = response
+
+        mock_build_opener.return_value.open.return_value = response
+
+        headers = fetch_response_headers(
+            "https://example.com"
+        )
+
+        self.assertEqual(
+            headers["Strict-Transport-Security"],
+            "max-age=31536000",
+        )
+
+        self.assertEqual(
+            headers["Content-Security-Policy"],
+            "default-src 'self'",
+        )
+
+    @patch("argus_guard.http_client.build_opener")
+    def test_network_failure(self, mock_build_opener):
+        mock_build_opener.return_value.open.side_effect = (
+            URLError("Connection failed")
+        )
+
+        with self.assertRaises(HeaderFetchError):
+            fetch_response_headers(
+                "https://example.com"
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

argus_guard-0.1.0a1/tests/test_security_headers.py

@@ -0,0 +1,88 @@
+"""
+ARGUS — Security Headers Tests
+==============================
+
+Unit tests for HTTP security header analysis.
+
+Author: Irena Popova
+"""
+
+import unittest
+
+from argus_guard.security_headers import (
+    audit_security_headers,
+    calculate_header_coverage,
+)
+
+
+class TestSecurityHeaders(unittest.TestCase):
+
+    def test_all_headers_present(self):
+        """Verify detection when all headers are present."""
+
+        headers = {
+            "Strict-Transport-Security": "max-age=31536000",
+            "Content-Security-Policy": "default-src 'self'",
+            "X-Content-Type-Options": "nosniff",
+            "Referrer-Policy": "strict-origin",
+        }
+
+        results = audit_security_headers(headers)
+
+        self.assertTrue(all(results.values()))
+
+        self.assertEqual(
+            calculate_header_coverage(results),
+            100.0,
+        )
+
+    def test_missing_headers(self):
+        """Verify detection of missing security headers."""
+
+        headers = {
+            "Content-Security-Policy": "default-src 'self'",
+        }
+
+        results = audit_security_headers(headers)
+
+        self.assertFalse(
+            results["strict-transport-security"]
+        )
+
+        self.assertFalse(
+            results["x-content-type-options"]
+        )
+
+        self.assertEqual(
+            calculate_header_coverage(results),
+            25.0,
+        )
+
+    def test_case_insensitive_headers(self):
+        """HTTP header names must be case-insensitive."""
+
+        headers = {
+            "CONTENT-SECURITY-POLICY": "default-src 'self'",
+        }
+
+        results = audit_security_headers(headers)
+
+        self.assertTrue(
+            results["content-security-policy"]
+        )
+
+    def test_empty_headers(self):
+        """Verify handling of an empty HTTP header collection."""
+
+        results = audit_security_headers({})
+
+        self.assertFalse(any(results.values()))
+
+        self.assertEqual(
+            calculate_header_coverage(results),
+            0.0,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()