regscale-cli 6.16.0.0__py3-none-any.whl

tests/regscale/core/test_validation_utils.py

@@ -0,0 +1,163 @@
+from random import randint, random
+from unittest.mock import Mock
+
+import pytest
+
+from regscale.integrations.integration_override import IntegrationOverride
+from regscale.models.integration_models.tenable_models.models import Family, Repository, Severity, TenableAsset
+
+
+@pytest.fixture
+def random_local_ip():
+    """
+    Returns a random local ip address
+    """
+
+    # ip
+    return f"192.168.{randint(0, 255)}.{randint(0, 255)}"
+
+
+@pytest.fixture
+def tenable_asset(random_local_ip):
+    return TenableAsset(
+        pluginID="1234",
+        severity=Severity(id="high", name="High", description="High"),
+        hasBeenMitigated="false",
+        acceptRisk="false",
+        recastRisk="false",
+        ip=random_local_ip,
+        uuid="test-uuid",
+        port="80",
+        protocol="tcp",
+        pluginName="Test Plugin",
+        firstSeen="2024-01-01",
+        lastSeen="2024-01-02",
+        exploitAvailable="true",
+        exploitEase="easy",
+        exploitFrameworks="test",
+        synopsis="test",
+        description="test",
+        solution="test",
+        seeAlso="test",
+        riskFactor="High",
+        stigSeverity="High",
+        vprScore="9.0",
+        vprContext="test",
+        baseScore="9.0",
+        temporalScore="9.0",
+        cvssVector="test",
+        cvssV3BaseScore="9.0",
+        cvssV3TemporalScore="9.0",
+        cvssV3Vector="test",
+        cpe="test",
+        vulnPubDate="2024-01-01",
+        patchPubDate="2024-01-01",
+        pluginPubDate="2024-01-01",
+        pluginModDate="2024-01-01",
+        checkType="test",
+        version="1.0",
+        cve="CVE-2024-1234",
+        bid="1234",
+        xref="test",
+        pluginText="test",
+        dnsName="test.example.com",
+        macAddress="00:11:22:33:44:55",
+        netbiosName="TEST",
+        operatingSystem="Linux",
+        ips=random_local_ip,
+        recastRiskRuleComment="test",
+        acceptRiskRuleComment="test",
+        hostUniqueness="test",
+        acrScore="9.0",
+        keyDrivers="test",
+        uniqueness="test",
+        family=Family(id="1", name="Test Family", type="Test Type"),
+        repository=Repository(id="rep", name="Test", description="Test", dataFormat="Test"),
+        pluginInfo="test",
+    )
+
+
+def test_field_map_validation_with_dict(tenable_asset, random_local_ip):
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress"]}}
+    override = IntegrationOverride(app)
+
+    dict_cases = [
+        ({"ipv4": random_local_ip}, random_local_ip),
+        ({}, None),
+        ({"ipv4": None}, None),
+        ({"other_field": "value"}, None),
+    ]
+
+    for test_input, expected in dict_cases:
+        assert override.field_map_validation(test_input, "asset") == expected
+
+
+def test_field_map_validation_with_tenable_asset(tenable_asset, random_local_ip):
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress"]}}
+    override = IntegrationOverride(app)
+
+    assert override.field_map_validation(tenable_asset, "asset") == random_local_ip
+
+
+def test_field_map_validation_with_multiple_fields(random_local_ip):
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress", "macAddress", "hostname"]}}
+    override = IntegrationOverride(app)
+    dict_obj = {"ipv4": random_local_ip, "mac": "00:11:22:33:44:55", "hostname": "test.example.com"}
+    assert override.field_map_validation(dict_obj, "asset") == random_local_ip
+
+
+def test_field_map_validation_with_empty_and_invalid_configs(random_local_ip):
+    app = Mock()
+    dict_obj = {"ipv4": random_local_ip, "mac": "00:11:22:33:44:55", "hostname": "test.example.com"}
+
+    # Invalid configs here
+    config_cases = [
+        ({}, None),
+        ({"uniqueOverride": {}}, None),
+        ({"uniqueOverride": {"asset": []}}, None),
+        ({"uniqueOverride": None}, None),
+        ({"uniqueOverride": {"issue": ["title"]}}, None),  # issue is not supported yet ..
+        ({"uniqueOverride": {"invalid_type": ["ipAddress"]}}, None),
+        ({"uniqueOverride": {"asset": [None]}}, None),
+    ]
+
+    for config, expected in config_cases:
+        app.config = config
+        override = IntegrationOverride(app)
+        try:
+            key = next(iter(config.get("uniqueOverride", {})), None)
+        except TypeError:
+            key = None
+        assert override.field_map_validation(dict_obj, key) == expected
+        del override
+
+
+def test_field_map_validation_with_multiple_fields_for_multiple_integrations(random_local_ip):
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress"]}}
+    override = IntegrationOverride(app)
+
+    dict_obj = {"ipv4": random_local_ip, "mac": "00:11:22:33:44:55", "hostname": "test.example.com"}
+    assert override.field_map_validation(dict_obj, "invalid_type") is None
+
+
+def test_field_map_validation_with_invalid_model_types(random_local_ip):
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress"]}}
+    override = IntegrationOverride(app)
+    dict_obj = {"ipv4": random_local_ip, "mac": "00:11:22:33:44:55", "hostname": "test.example.com"}
+
+    assert override.field_map_validation(dict_obj, "invalid_type") is None
+
+
+def test_field_map_validation_with_non_dict_non_model_objects():
+    app = Mock()
+    app.config = {"uniqueOverride": {"asset": ["ipAddress"]}}
+    override = IntegrationOverride(app)
+
+    invalid_objects = [None, "string", 123, ["list"]]
+    for obj in invalid_objects:
+        assert override.field_map_validation(obj, "asset") is None

tests/regscale/core/test_version.py

@@ -0,0 +1,78 @@
+"""Tests for the version module."""
+
+from unittest.mock import patch
+import pytest
+import logging
+from regscale.utils.version import RegscaleVersion
+
+logger = logging.getLogger(__name__)
+
+
+@patch.object(RegscaleVersion, "get_platform_version", return_value="1.0.0.0")
+def test_get_platform_version(mock_get_platform_version):
+    """Test get_platform_version method."""
+    version = RegscaleVersion.get_platform_version()
+    assert isinstance(version, str) and RegscaleVersion.is_valid_version(version)
+
+
+@pytest.mark.parametrize(
+    "version, expected",
+    [
+        ("1.0", True),
+        ("1.0.0", True),
+        ("1.0.0.0", True),
+        ("1.0.0.0.0", False),
+        ("1.a.0", False),
+        ("1.0.a", False),
+        ("a.b.c", False),
+        ("1.0.0-alpha", False),
+        ("dev", False),
+        ("localdev", False),
+        ("1337-2024-10-25", False),
+    ],
+)
+def test_is_valid_version(version, expected):
+    """Test is_valid_version method."""
+    assert RegscaleVersion.is_valid_version(version) == expected
+
+
+@pytest.mark.parametrize(
+    "version1, version2, dev_is_latest, expected",
+    [
+        ("1.0.0", "1.0.1", True, False),
+        ("1.2.0", "1.0.1", True, True),
+        ("2.0.0", "1.9.9", True, True),
+        ("2.0.0", "42069-2013-07-14", True, True),
+        ("42069-2013-07-14", "2.0.0", True, True),
+        ("dev", "1.0.1", True, True),
+        ("1.0.0", "dev", True, False),
+        ("dev", "dev", True, True),
+        ("localdev", "1.0.1", True, True),
+        ("1.0.0", "localdev", True, False),
+        ("localdev", "localdev", True, True),
+        ("Unknown", "1.0.1", True, True),
+        ("1.0.0", "Unknown", True, False),
+        ("Unknown", "Unknown", True, True),
+    ],
+)
+def test_compare_versions(version1, version2, dev_is_latest, expected):
+    """Test compare_versions method."""
+    assert RegscaleVersion.compare_versions(version1, version2, dev_is_latest) == expected
+
+
+@pytest.mark.parametrize(
+    "minimum_version, dev_is_latest, expected",
+    [
+        ("1.0.0.0", True, True),
+        ("2.0.0", True, False),
+        ("dev", True, False),
+        ("dev", False, True),
+        ("localdev", True, False),
+        ("Unknown", True, False),
+        ("1337-2024-10-25", True, True),
+    ],
+)
+@patch.object(RegscaleVersion, "get_platform_version", return_value="1.0.0")
+def test_meets_minimum_version(mock_get_platform_version, minimum_version, dev_is_latest, expected):
+    """Test meets_minimum_version method."""
+    assert RegscaleVersion.meets_minimum_version(minimum_version, dev_is_latest) == expected

tests/regscale/models/test_asset.py

@@ -0,0 +1,71 @@
+import pytest
+
+from tests import CLITestFixture
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models import Search
+from regscale.models.regscale_models.asset import Asset
+
+
+class TestAssets(CLITestFixture):
+    bad_ssp_id = 10000
+    good_ssp_id = 3
+    regscale_module = "securityplans"
+
+    # Can we create an instance of the Asset class?
+    @staticmethod
+    def test_asset_instance():
+        asset = Asset(
+            host_name="host.example.com",
+            name="Host Name",
+            type="Other",
+            ipAddress="1.1.1.1",
+            parentId=1,
+            parentModule="securityplans",
+            assetOwnerId="asdfasdf",
+            status="Active (On Network)",
+            assetType="Virtual Machine (VM)",
+            dateCreated=get_current_datetime(),
+            dateLastUpdated=get_current_datetime(),
+            createdById="asdfasdf",
+            lastUpdatedById="asdfasdf",
+            assetCategory="Hardware",
+            scanningTool="Rando Scanner",
+            isPublic=True,
+            tenantsId=0,
+        )
+        assert isinstance(asset, Asset)
+
+    @staticmethod
+    def test_bad_asset():
+        asset = Asset(
+            host_name="host.example.com",
+            name="Host Name",
+            type="Other",
+            ipAddress="1.1.1.1",
+            parentId=1,
+            parentModule="securityplans",
+            assetOwnerId="asdfasdf",
+            status="Active (On Network)",
+            assetType="Virtual Machine (VM)",
+            dateCreated=get_current_datetime(),
+            dateLastUpdated=get_current_datetime(),
+            createdById="asdfasdf",
+            lastUpdatedById="asdfasdf",
+            assetCategory="Hardware",
+            scanningTool="Rando Scanner",
+            isPublic=True,
+            tenantsId=0,
+            fqdn=0,  # Bad attribute
+        )
+        # Check if an attribute error is raised
+        with pytest.raises(AttributeError):
+            asset.model_fields_set
+
+    def test_assets_by_search(self):
+        empty_search = Search(parentID=self.bad_ssp_id, module=self.regscale_module, sort="id")
+        search = Search(parentID=self.good_ssp_id, module=self.regscale_module, sort="id")
+        # this will return an empty list
+        no_assets = Asset.get_all_by_search(empty_search)
+        assets = Asset.get_all_by_search(search)
+        assert no_assets == []
+        assert len(assets) > 0

tests/regscale/models/test_config.py

@@ -0,0 +1,26 @@
+"""Test Providers and the AppConfig objects."""
+
+import inspect
+
+import pytest
+
+from regscale.models import config
+
+
+def test_Provider():
+    """Test the Provider class"""
+    results = config.Provider(provider="fake_provider")
+    assert results.provider == "fake_provider"
+    results.__setitem__("key", "value")
+    assert results.key == "value"
+    with pytest.raises(NotImplementedError):
+        results.refresh()
+
+
+def test_provider_class_creation():
+    """Test that the provider classes are created."""
+    providers = list(config.providers.keys())
+    # Get a list of all classes in the module
+    all_classes = [name for name, obj in inspect.getmembers(config) if inspect.isclass(obj)]
+    for provider in providers:
+        assert provider in all_classes, f"{provider} is not defined"

tests/regscale/models/test_control_implementation.py

@@ -0,0 +1,27 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from regscale.models import ControlImplementation
+
+
+class TestControlImplementation(unittest.TestCase):
+    @patch("regscale.models.regscale_models.control_implementation.ControlImplementation._get_api_handler().get")
+    def test_get_control_map_by_plan_lower_case_keys(self, mock_get):
+        # Create a mock response object with 'ok' attribute and 'json' method
+        mock_response = MagicMock()
+        mock_response.ok = True
+        mock_response.json.return_value = [
+            {"control": {"controlId": "CA-1"}, "id": 1},
+            {"control": {"controlId": "AC-6"}, "id": 2},
+        ]
+
+        mock_get.return_value = mock_response
+
+        # Expected result should have lower case control IDs as keys
+        expected_result = {"ca-1": 1, "ac-6": 2}
+
+        # Call the method under test
+        result = ControlImplementation.get_control_label_map_by_plan(plan_id=123)
+
+        # Assert that the result matches the expected result
+        self.assertEqual(result, expected_result)

tests/regscale/models/test_import.py

@@ -0,0 +1,97 @@
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from regscale.core.app.api import Api
+from regscale.core.app.utils.catalog_utils.download_catalog import get_new_catalog
+from regscale.core.app.utils.catalog_utils.update_catalog_v2 import import_catalog
+from regscale.models.app_models.catalog_compare import CatalogCompare
+from regscale.models.regscale_models import Catalog
+from tests.fixtures.test_fixture import CLITestFixture
+
+
+class TestImport(CLITestFixture):
+    """
+    Test for AWS integration
+    """
+
+    @pytest.fixture(autouse=False)
+    def setup(self, catalog_id):
+        # Setup code goes here. This will execute before each test method.
+        print("Setting up before test")
+        my_dir = tempfile.mkdtemp()
+        api = Api()
+        # You can initialize variables, create necessary objects, or set up any necessary preconditions for the test here.
+        data = CatalogCompare.get_master_catalogs(api=api)
+        # download json file with requests
+        for catalog in data["catalogs"]:
+            if catalog["downloadURL"] and catalog["title"] == "Australian Information Security Manual (ISM)":
+                url = catalog["downloadURL"]
+                name = Path(catalog["downloadURL"]).name
+                cat = get_new_catalog(url=url)
+                with open(Path(tempfile.gettempdir()) / my_dir / name, "w") as f:
+                    json.dump(cat, f)
+                catalog_id["name"] = name
+                catalog_id["file"] = Path(tempfile.gettempdir()) / my_dir / name
+                break
+        # Download a bad file
+        bad_url = (
+            "https://gist.githubusercontent.com/moredip/4165313/raw/ad00ee5bc70016a70976736d5cdf0463d5f7ea15/test.json"
+        )
+        bad_name = Path(bad_url).name
+        bad_cat = get_new_catalog(url=bad_url)
+        catalog_id["bad_name"] = "Invalid JSON"
+        catalog_id["bad_file"] = Path(tempfile.gettempdir()) / my_dir / bad_name
+        with open(catalog_id["bad_file"], "w") as bad_file:
+            json.dump(bad_cat, bad_file)
+
+    @pytest.fixture(scope="module")
+    def catalog_id(self):
+        return {}
+
+    @pytest.fixture(autouse=False)
+    def teardown(self, catalog_id):
+        yield  # This is where the test function will execute
+        # Teardown code goes here. This will execute after each test method.
+        print("Tearing down after test")
+
+        if cat_id := catalog_id.get("id"):
+            if cat := Catalog.get_object(cat_id):
+                assert cat.delete() is True
+
+    def test_import_catalog_invalid(self, setup, catalog_id):
+        # Arrange
+        catalog_path = Path(catalog_id["bad_file"])
+
+        # Act
+        res = import_catalog(catalog_path)
+        # Assert
+        assert res.json()["success"] is False
+
+    # @pytest.skip("Skipping test because the API keeps timing out even in the application.")
+    def test_import_catalog_valid(self, setup, teardown, catalog_id):
+        # Arrange
+        catalog_path = Path(catalog_id["file"])
+        # change the catalog name to include the name of the test run id
+        with open(catalog_path, "r", encoding="utf-8") as infile:
+            data = json.load(infile)
+        with open(catalog_path, "w", encoding="utf-8") as outfile:
+            current_title = data["catalog"]["title"]
+            data["catalog"]["title"] = self.title_prefix + current_title
+            json.dump(data, outfile, indent=4)
+
+        # Act
+        res = import_catalog(catalog_path)
+        if res.status_code == 400 and res.text == "Catalog already exists":
+            pytest.skip("Catalog already exists. Most likely due to another test. Skipping import.")
+        # Assert
+        assert res.json()["success"] is True
+        cat_id = res.json()["catalogId"]
+        catalog_id["id"] = cat_id
+        assert cat_id is not None
+
+        # delete the catalog
+        new_cat = Catalog.get_object(cat_id)
+        assert new_cat.delete() is True

tests/regscale/models/test_issue.py

@@ -0,0 +1,36 @@
+import pytest
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.issue import Issue, IssueSeverity, IssueStatus
+
+
+def test_bad_issue_instance():
+    issue = Issue(
+        id=1,
+        title="Test Issue",
+        severityLevel=IssueSeverity.NotAssigned,
+        status=IssueStatus.Draft,
+        description="This is a test issue",
+        parentId=1,
+        parentModule="securityplans",
+        pluginId=1,
+        dateCreated=get_current_datetime(),
+    )
+    # Assert issue.model_fields_set raises an AttributeError
+    with pytest.raises(AttributeError):
+        issue.model_fields_set
+
+
+def test_good_issue_instance():
+    issue = Issue(
+        id=1,
+        title="Test Issue",
+        severityLevel=IssueSeverity.NotAssigned,
+        status=IssueStatus.Draft,
+        description="This is a test issue",
+        parentId=1,
+        parentModule="securityplans",
+        pluginId=str(1),
+        dateCreated=get_current_datetime(),
+    )
+    assert isinstance(issue, Issue)

tests/regscale/models/test_mapping.py

@@ -0,0 +1,52 @@
+from regscale.models.app_models.mapping import Mapping
+import json
+
+MAPPING_TEMPLATE = {
+    "mapping": {
+        "Pickles": "Pickles",
+        "IP Address": "IP Address",
+        "Hostname": "Hostname",
+        "OS": "OS",
+        "Vulnerability Title": "Vulnerability Title",
+        "Vulnerability ID": "Vulnerability ID",
+        "CVSSv2 Score": "CVSSv2 Score",
+        "CVSSv3 Score": "CVSSv3 Score",
+        "Description": "Description",
+        "Proof": "Proof",
+        "Solution": "Solution",
+        "CVEs": "CVEs",
+    }
+}
+
+
+def test_mapping_validation():
+    """
+    Test the Mapping class validation
+    """
+    expected_field_names = [
+        "IP Address",
+        "Hostname",
+        "OS",
+        "Vulnerability Title",
+        "Vulnerability ID",
+        "CVSSv2 Score",
+        "CVSSv3 Score",
+        "Description",
+        "Proof",
+        "Solution",
+        "CVEs",
+    ]
+    mapping = Mapping(mapping=MAPPING_TEMPLATE["mapping"], expected_field_names=expected_field_names)
+
+    assert mapping
+
+
+def test_mapping_no_validation():
+    """
+    Test the Mapping class validation
+    """
+
+    expected_field_names = ["Pickles"]
+    mapping = Mapping(mapping=MAPPING_TEMPLATE["mapping"], expected_field_names=expected_field_names)
+
+    assert mapping

tests/regscale/models/test_platform.py

@@ -0,0 +1,31 @@
+"""Test the platform module."""
+
+from unittest.mock import patch
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.models import platform
+
+PATH = "regscale.models.platform"
+
+
+@patch(f"{PATH}.get_regscale_token", return_value=("billy", "zane"))
+def test_RegScaleAuth_model_behaves(mock_get_regscale_token):
+    """The RegScaleAuth BaseModel class does lots of things, let's test them."""
+    api = Api()
+    un = "funkenstein"
+    pw = "groovin'tothewaveoftheflag"
+    domain = "disinfo.org"
+    model = platform.RegScaleAuth.authenticate(
+        api=api,
+        username=un,
+        password=pw,
+        domain=domain,
+    )
+    mock_get_regscale_token.assert_called_once()
+    assert isinstance(model, platform.RegScaleAuth)
+    assert model.token == "Bearer zane"
+    assert model.user_id == "billy"
+    assert model.username == un
+    assert model.password.get_secret_value() == pw
+    assert model.domain == domain