regscale-cli 6.16.0.0__py3-none-any.whl

tests/fixtures/models.py

@@ -0,0 +1,91 @@
+from typing import List, Type, TypeVar
+
+import pytest
+from unittest.mock import patch
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.models import regscale_models
+
+T = TypeVar("T", bound=RegScaleModel)
+
+
+@pytest.fixture
+def mock_regscale_models(mock_api_handler):
+    """
+    Fixture to patch various methods for RegScaleModel and its subclasses to use model cache and avoid API calls.
+
+    :param mock_api_handler: Mocked API handler
+    :yield: None
+    """
+
+    def mock_get_all_by_parent(cls: Type[T], parent_id: int, *args, **kwargs) -> List[T]:
+        """
+        Mock method to get all objects by parent ID.
+
+        :param Type[T] cls: The class of the objects to retrieve
+        :param int parent_id: The ID of the parent object
+        :return: List of objects matching the parent ID and other criteria
+        """
+        parent_module = kwargs.get("parent_module")
+
+        return [
+            obj
+            for obj in cls._object_cache.values()
+            if isinstance(obj, cls)
+            and parent_id == getattr(obj, cls._parent_id_field)
+            and (not parent_module or obj.parentModule == parent_module)
+        ]
+
+    def mock_issue_find_by_other_identifier(other_identifier: str) -> List[regscale_models.Issue]:
+        """
+        Mock method to find issues by other identifier.
+
+        :param str other_identifier: The other identifier to search for
+        :return: List of Issue objects matching the other identifier
+        """
+        return [
+            issue
+            for issue in regscale_models.Issue._object_cache.values()
+            if isinstance(issue, regscale_models.Issue) and issue.otherIdentifier == other_identifier
+        ]
+
+    def mock_vulnerability_mapping_find_by_issue(
+        issue_id: int, status: str = "all"
+    ) -> List[regscale_models.VulnerabilityMapping]:
+        """
+        Mock method to find vulnerability mappings by issue ID and status.
+
+        :param int issue_id: The ID of the issue to search for
+        :param str status: The status of the vulnerability mapping (default: "all")
+        :return: List of VulnerabilityMapping objects matching the criteria
+        """
+        return [
+            mapping
+            for mapping in regscale_models.VulnerabilityMapping._object_cache.values()
+            if isinstance(mapping, regscale_models.VulnerabilityMapping)
+            and (status == "all" or mapping.status.lower() == status.lower())
+        ]
+
+    def mock_get_object(cls: Type[T], object_id: int) -> T:
+        """
+        Mock method to get an object by its ID.
+
+        :param Type[T] cls: The class of the object to retrieve
+        :param int object_id: The ID of the object to retrieve
+        :return: The object if found, None otherwise
+        """
+        # Try to get the object from the cache first
+        cached_object = next((obj for obj in cls._object_cache.values() if obj.id == object_id), None)
+        if cached_object:
+            return cached_object
+
+        # If not in cache, simulate an API call (you might want to raise an exception here instead)
+        return None
+
+    with patch.object(RegScaleModel, "get_all_by_parent", classmethod(mock_get_all_by_parent)), patch.object(
+        regscale_models.Issue, "find_by_other_identifier", mock_issue_find_by_other_identifier
+    ), patch.object(
+        regscale_models.VulnerabilityMapping, "find_by_issue", mock_vulnerability_mapping_find_by_issue
+    ), patch.object(
+        RegScaleModel, "get_object", classmethod(mock_get_object)
+    ):
+        yield

tests/fixtures/test_fixture.py

@@ -0,0 +1,144 @@
+"""Test fixture class used during CLI testing"""
+
+import logging
+import os
+import random
+import sys
+import uuid
+from logging import Logger
+from pathlib import Path
+from typing import Optional, Union
+
+import pytest
+import yaml
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.internal.login import login
+from tests.conftest_utils import INIT_CONF_PYTEST
+
+
+class CLITestFixture:
+    """
+    Test fixture for the CLI application
+    """
+
+    app: Application
+    api: Api
+    config: dict
+    logger: Logger
+    title_prefix: str
+
+    def update_config_with_env(self):
+        """
+        Update the Application.config values with the corresponding env values if both conditions are met:
+        - the config value is the same as the template
+        - the env value is not empty
+        """
+        key_env = {
+            "domain": "REGSCALE_DOMAIN",
+            "token": "REGSCALE_TOKEN",
+            "jiraUrl": "JIRA_URL",
+            "jiraUserName": "JIRA_USERNAME",
+            "jiraApiToken": "JIRA_API_TOKEN",
+            "wizClientId": "WIZCLIENTID",
+            "wizClientSecret": "WIZCLIENTSECRET",
+            "snowUrl": "SNOW_URL",
+            "snowUserName": "SNOW_USERNAME",
+            "snowPassword": "SNOW_PASSWORD",
+            "sicuraUrl": "SICURA_URL",
+            "sicuraToken": "SICURA_TOKEN",
+            "nistCpeApiKey": "NIST_CPE_API_KEY",
+            "qualysUserName": "QUALYS_USERNAME",
+            "qualysPassword": "QUALYS_PASSWORD",
+            "qualysUrl": "QUALYS_URL",
+        }
+        for key, env in key_env.items():
+            config_value = self.app.config.get(key, "")
+            template_value = self.app.template.get(key, "")
+            env_value = os.getenv(env, "")
+            self.app.config[key] = env_value if config_value == template_value and env_value else config_value
+
+        hard_coded_test_values = {
+            "gcpScanType": "organization",
+            "gcpOrganizationId": "000000000000",
+            "timeout": 360,
+        }
+        for key, value in hard_coded_test_values.items():
+            self.app.config[key] = value
+
+    def verify_config(self, config_key: Union[str, list[str]], compare_template: bool = True) -> None:
+        """
+        Verify the configuration values and compare them to the template
+
+        :param Union[str, list[str]] config_key: Configuration key or list of keys to verify
+        :param bool compare_template: Whether to compare the configuration values to the template, defaults to True
+        :rtype: None
+        """
+        if isinstance(config_key, list):
+            for key in config_key:
+                self.verify_config(key, compare_template)
+        else:
+            assert self.app.config.get(config_key) is not None
+            if compare_template:
+                assert self.app.config.get(config_key) != self.app.template.get(config_key)
+
+    @staticmethod
+    def get_tests_dir(suffix: Optional[Union[str, Path]] = None) -> Path:
+        """
+        Get the current working directory
+
+        :param Optional[Union[str, Path]] suffix: The suffix to append to the path, defaults to None
+        :return: Path of the responses directory with a trailing slash
+        :rtype: Path
+        """
+        cur_dir = Path(os.getcwd())
+        if cur_dir.stem.lower() in ["commercial", "internal", "public"]:
+            # get the repo root
+            # EX: regscale-cli/tests/regscale/integrations/INTEGRATIONTYPE/test_name.py
+            cwd = cur_dir.parent.parent.parent.parent
+        elif cur_dir.stem.lower() == "tests":
+            cwd = Path("../")
+        else:
+            cwd = Path(os.getcwd())
+        return cwd / suffix if suffix else cwd
+
+    @pytest.fixture(autouse=True)
+    def cli_test_fixture(self, request):
+        """
+        Test fixture for the CLI application
+
+        :param request: Pytest request object
+        :return: RegScale CLI Application object
+        :rtype: Application
+        """
+        logger = logging.getLogger(__name__)
+        logger.info("Test Setup")
+
+        # Application is already set up, so we just need to update the config with the environment variables
+        self.app = Application()
+        self.app.local_config = False
+        self.update_config_with_env()
+        # Convert the INIT_CONF_PYTEST string into a dictionary
+        config_dict = yaml.safe_load(INIT_CONF_PYTEST)
+        test_config = {**config_dict, **self.app.config}
+        self.app.save_config(test_config)
+        self.config = self.app.config
+        python_info = f"Python{sys.version_info.major}.{sys.version_info.minor}"
+        random_id = uuid.uuid3(uuid.NAMESPACE_DNS, python_info)
+        self.title_prefix = f"{python_info} Test {random_id} - "
+        # login with token if available
+        if token := os.getenv("REGSCALE_TOKEN") or self.config.get("token"):
+            login(token=token, app=self.app)
+        elif "REGSCALE_USERNAME" in os.environ and "REGSCALE_PASSWORD" in os.environ:
+            login(
+                str_user=os.getenv("REGSCALE_USERNAME"),
+                str_password=os.getenv("REGSCALE_PASSWORD"),
+                app=self.app,
+            )
+        self.api = Api()
+        self.logger = logger
+
+        logger.info(f"Test Setup Complete: {self.title_prefix}")
+        # Test Execution
+        yield self.app

tests/mocks/objects.py

@@ -0,0 +1,3 @@
+"""Provide generic and mocked python objects to call in tests."""
+
+GENERIC_DICT = {"key": "value"}

tests/mocks/response.py

@@ -0,0 +1,32 @@
+"""Create mocked requests.Response objects."""
+
+from unittest.mock import Mock
+
+import requests
+
+
+def create_mock_response(
+    status_code=200,
+    json_data=None,
+    text_data=None,
+    headers=None,
+    ok=True,
+):
+    """
+    Generate a custom requests.Response object using unittest.mock.
+
+    :status_code (int, optional): The HTTP status code for the response.
+    :json_data (dict, optional): The JSON data to be returned by the response's json() method.
+    :text_data (str, optional): The text data to be returned by the response's text attribute.
+    :headers (dict, optional): The headers for the response.
+    :ok (bool, optional): The response.ok value.
+
+    :returns Mock: A unittest.mock.Mock instance with the specified attributes and behavior.
+    """
+    mock_response = Mock(spec=requests.Response)
+    mock_response.status_code = status_code
+    mock_response.json.return_value = json_data
+    mock_response.text = text_data
+    mock_response.headers = headers or {}
+    mock_response.ok = ok
+    return mock_response

tests/mocks/xml.py

@@ -0,0 +1,13 @@
+"""Provide mock content for XML functions."""
+
+XML_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
+<root>
+    <item>
+        <id>1</id>
+        <name>Item 1</name>
+    </item>
+    <item>
+        <id>2</id>
+        <name>Item 2</name>
+    </item>
+</root>"""

tests/regscale/core/test_api.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for the Api class"""
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from regscale.core.app.api import Api, normalize_url
+from regscale.core.app.application import Application
+
+
+@pytest.fixture
+def mock_config():
+    """Fixture for mocking config"""
+    return {
+        "token": "test-token",
+        "domain": "https://api.example.com",
+        "maxThreads": 10,
+        "ssl_verify": True,
+        "timeout": 10,
+    }
+
+
+@pytest.fixture
+def api(mock_config):
+    """Fixture for creating an Api instance with mocked config"""
+    with patch("regscale.core.app.application.Application") as mock_app:
+        mock_app.return_value.config = mock_config
+        api = Api()
+        api.session = MagicMock()
+        return api
+
+
+def test_handle_headers_with_no_merge(api):
+    """Test _handle_headers when merge_headers is False"""
+    custom_headers = {"Custom-Header": "value"}
+    result = api._handle_headers(custom_headers, merge_headers=False)
+    assert result == custom_headers
+
+
+def test_handle_headers_with_merge(api):
+    """Test _handle_headers when merge_headers is True"""
+    custom_headers = {"Custom-Header": "value"}
+    result = api._handle_headers(custom_headers, merge_headers=True)
+
+    assert result["Custom-Header"] == "value"
+    assert result["accept"] == api.accept
+    assert result["Content-Type"] == api.content_type
+    assert result["Authorization"] == "test-token"
+
+
+def test_handle_headers_with_no_headers(api):
+    """Test _handle_headers when headers is None"""
+    # When merge_headers is False, should return empty dict for None headers
+    result = api._handle_headers(None, merge_headers=False)
+    assert result["accept"] == api.accept
+    assert result["Content-Type"] == api.content_type
+    assert result["Authorization"] == "test-token"
+
+    # When merge_headers is True, should return default headers
+    result = api._handle_headers(None, merge_headers=True)
+    assert result["accept"] == api.accept
+    assert result["Content-Type"] == api.content_type
+    assert result["Authorization"] == "test-token"
+
+
+def test_handle_headers_with_empty_headers(api):
+    """Test _handle_headers when headers is an empty dict"""
+    result = api._handle_headers({}, merge_headers=True)
+
+    assert len(result) == 3
+    assert result["accept"] == api.accept
+    assert result["Content-Type"] == api.content_type
+    assert result["Authorization"] == "test-token"
+
+    # Test with merge_headers=False
+    result = api._handle_headers({}, merge_headers=False)
+    assert result == {}
+
+
+def test_get_request_success(api):
+    """Test successful GET request"""
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '{"data": "test"}'
+    api.session.get.return_value = mock_response
+
+    response = api.get("https://api.example.com/test")
+
+    assert response.status_code == 200
+    assert response.text == '{"data": "test"}'
+    api.session.get.assert_called_once()
+
+
+def test_post_request_success(api):
+    """Test successful POST request"""
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '{"data": "created"}'
+    api.session.post.return_value = mock_response
+
+    json_data = {"key": "value"}
+    response = api.post("https://api.example.com/test", json=json_data)
+
+    assert response.status_code == 200
+    assert response.text == '{"data": "created"}'
+    api.session.post.assert_called_once()
+
+
+def test_put_request_success(api):
+    """Test successful PUT request"""
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '{"data": "updated"}'
+    api.session.put.return_value = mock_response
+
+    json_data = {"key": "value"}
+    response = api.put("https://api.example.com/test", json=json_data)
+
+    assert response.status_code == 200
+    assert response.text == '{"data": "updated"}'
+    api.session.put.assert_called_once()
+
+
+def test_delete_request_success(api):
+    """Test successful DELETE request"""
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = '{"data": "deleted"}'
+    api.session.delete.return_value = mock_response
+
+    response = api.delete("https://api.example.com/test")
+
+    assert response.status_code == 200
+    assert response.text == '{"data": "deleted"}'
+    api.session.delete.assert_called_once()
+
+
+def test_request_with_401_retry(api):
+    """Test request handling 401 unauthorized with retry"""
+    mock_response_401 = MagicMock()
+    mock_response_401.status_code = 401
+
+    mock_response_200 = MagicMock()
+    mock_response_200.status_code = 200
+    mock_response_200.text = '{"data": "success"}'
+
+    api.session.get.side_effect = [mock_response_401, mock_response_200]
+
+    with patch.object(api, "_handle_401", return_value=True):
+        response = api.get("https://api.example.com/test")
+
+        assert response.status_code == 200
+        assert response.text == '{"data": "success"}'
+        assert api.session.get.call_count == 2
+
+
+def test_normalize_url():
+    """Test URL normalization"""
+    test_cases = [
+        ("http://example.com//api//v1/", "http://example.com/api/v1"),
+        ("example.com/api/v1", "http://example.com/api/v1"),
+        ("https://example.com/api//v1", "https://example.com/api/v1"),
+        ("http://example.com/api/v1/", "http://example.com/api/v1"),
+    ]
+
+    for input_url, expected_url in test_cases:
+        assert normalize_url(input_url) == expected_url
+
+
+def test_graph_query_success(api):
+    """Test successful GraphQL query"""
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "data": {"vulnerabilities": {"items": [{"id": 1}], "pageInfo": {"hasNextPage": False}}}
+    }
+
+    api.session.post.return_value = mock_response
+    query = """
+    query {
+        vulnerabilities {
+            items {
+                id
+            }
+        }
+    }
+    """
+    result = api.graph(query)
+
+    assert "vulnerabilities" in result
+    assert isinstance(result["vulnerabilities"]["items"], list)
+    assert result["vulnerabilities"]["items"][0]["id"] == 1
+    api.session.post.assert_called_once()
+
+
+def test_ssl_verify_false_envar():
+    """Test that SSL verification setting is passed to the session via envar"""
+    with patch.dict(os.environ, {"sslVerify": "false"}):
+        assert os.getenv("sslVerify") == "false"
+        api = Api()
+        assert api.session.verify is False
+
+
+def test_ssl_verify_true_envar():
+    """Test that SSL verification setting is passed to the session via envar"""
+    with patch.dict(os.environ, {"sslVerify": "true"}):
+        assert os.getenv("sslVerify") == "true"
+        api = Api()
+        assert api.verify is True
+        assert api.session.verify is True
+
+
+def test_ssl_verify_false_config():
+    """Test that SSL verification setting is passed to the session via init.yaml"""
+    app = Application(config={"sslVerify": False})
+    app.config_file = "test_ssl_verify_false_config.yaml"
+    app.save_config(app.config)
+    assert app.config["sslVerify"] is False
+    api = Api()
+    assert api.verify is False
+    assert api.session.verify is False
+    # os.remove(app.config_file)
+
+
+def test_ssl_verify_true_config():
+    """Test that SSL verification setting is passed to the session init.yaml"""
+    app = Application(config={"sslVerify": True})
+    assert app.config["sslVerify"] is True
+    api = Api()
+    assert api.session.verify is True