test: add long awaited changelog tests

Author: jondricek

tests/changelog/cli/test_api.py

@@ -0,0 +1,186 @@
+"""Tests for the high-level API functions and parameter validation."""
+
+import pytest
+
+from mitreattack.diffStix.changelog_helper import get_new_changelog_md
+
+
+class TestCliApi:
+    """Tests for the high-level API functions and parameter validation."""
+
+    def test_get_new_changelog_md_basic(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, assert_markdown_structure
+    ):
+        """Test basic changelog generation with real DiffStix."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        result = get_new_changelog_md(domains=["enterprise-attack"], old=old_dir, new=new_dir, verbose=False)
+
+        assert_markdown_structure(result)
+
+    def test_get_new_changelog_md_layers_default(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, assert_markdown_structure
+    ):
+        """Test layer generation with default empty list."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        result = get_new_changelog_md(
+            domains=["enterprise-attack"],
+            layers=[],  # Empty list should trigger default layer generation
+            old=old_dir,
+            new=new_dir,
+            verbose=False,
+        )
+
+        assert_markdown_structure(result)
+
+    def test_get_new_changelog_md_with_options(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, assert_markdown_structure
+    ):
+        """Test get_new_changelog_md with various options."""
+        old_dir, new_dir = setup_test_directories(
+            tmp_path, minimal_stix_bundles, ["enterprise-attack", "mobile-attack"]
+        )
+
+        site_prefix = "https://example.com"
+
+        result = get_new_changelog_md(
+            domains=["enterprise-attack", "mobile-attack"],
+            old=old_dir,
+            new=new_dir,
+            show_key=True,  # Should add key to markdown
+            site_prefix=site_prefix,  # Should affect link generation
+            unchanged=True,  # Should include unchanged objects
+            verbose=False,  # Keep false for test speed
+            include_contributors=False,
+        )
+
+        assert_markdown_structure(result)
+        assert "## Key" in result  # show_key=True should add key section
+        assert "Enterprise" in result  # Should have enterprise domain
+        assert "Mobile" in result  # Should have mobile domain
+        assert site_prefix in result  # Should have site prefix in links
+
+    def test_get_new_changelog_md_markdown_file_only(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, validate_markdown_file
+    ):
+        """Test generating only markdown file with real content."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        markdown_file = tmp_path / "test_markdown.md"
+
+        result = get_new_changelog_md(
+            domains=["enterprise-attack"],
+            markdown_file=str(markdown_file),
+            old=old_dir,
+            new=new_dir,
+            verbose=False,
+        )
+
+        # Use shared validation utility
+        file_content = validate_markdown_file(markdown_file)
+        assert result == file_content  # Return value should match file content
+
+    def test_get_new_changelog_md_json_file_only(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, validate_json_file, assert_markdown_structure
+    ):
+        """Test generating only JSON file with real content."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        json_file = tmp_path / "test_changes.json"
+
+        result = get_new_changelog_md(
+            domains=["enterprise-attack"], json_file=str(json_file), old=old_dir, new=new_dir, verbose=False
+        )
+
+        # Use shared validation utilities
+        validate_json_file(json_file, ["enterprise-attack"])
+        assert_markdown_structure(result)  # Should still return markdown
+
+    def test_get_new_changelog_md_layer_files_only(
+        self,
+        minimal_stix_bundles,
+        tmp_path,
+        setup_test_directories,
+        create_layer_paths,
+        validate_layer_file,
+        assert_markdown_structure,
+    ):
+        """Test generating only layer files with real content."""
+        domains = ["enterprise-attack", "mobile-attack", "ics-attack"]
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, domains)
+
+        # Use shared helper to create layer file paths
+        layer_files = create_layer_paths(tmp_path, domains, prefix="test")
+
+        result = get_new_changelog_md(
+            domains=domains,
+            layers=layer_files,
+            old=old_dir,
+            new=new_dir,
+            verbose=False,
+        )
+
+        # Use shared validation utilities
+        for i, domain in enumerate(domains):
+            validate_layer_file(layer_files[i], domain)
+        assert_markdown_structure(result)  # Should still return markdown
+
+    def test_get_new_changelog_md_single_domain(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, assert_markdown_structure
+    ):
+        """Test get_new_changelog_md with single domain."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        result = get_new_changelog_md(domains=["enterprise-attack"], old=old_dir, new=new_dir, verbose=False)
+
+        assert_markdown_structure(result)
+        assert "Enterprise" in result  # Should only have enterprise section
+        assert "Mobile" not in result  # Should not have mobile section
+
+    def test_get_new_changelog_md_all_domains(
+        self, minimal_stix_bundles, tmp_path, setup_test_directories, assert_markdown_structure
+    ):
+        """Test get_new_changelog_md with all domains."""
+        old_dir, new_dir = setup_test_directories(
+            tmp_path, minimal_stix_bundles, ["enterprise-attack", "mobile-attack", "ics-attack"]
+        )
+
+        result = get_new_changelog_md(
+            domains=["enterprise-attack", "mobile-attack", "ics-attack"],
+            old=old_dir,
+            new=new_dir,
+            verbose=False,
+        )
+
+        assert_markdown_structure(result)
+        assert "Enterprise" in result
+        assert "Mobile" in result
+        assert "ICS" in result
+
+    def test_get_new_changelog_md_error_handling(self):
+        """Test error handling in get_new_changelog_md with real error conditions."""
+        # Test with nonexistent directories
+        with pytest.raises((FileNotFoundError, OSError)):
+            get_new_changelog_md(
+                domains=["enterprise-attack"], old="/nonexistent/old_dir", new="/nonexistent/new_dir", verbose=False
+            )
+
+    def test_get_new_changelog_md_file_write_error(self, minimal_stix_bundles, tmp_path, setup_test_directories):
+        """Test handling of file write errors with real file operations."""
+        old_dir, new_dir = setup_test_directories(tmp_path, minimal_stix_bundles, ["enterprise-attack"])
+
+        # Create readonly directory
+        readonly_dir = tmp_path / "readonly"
+        readonly_dir.mkdir()
+        readonly_dir.chmod(0o444)
+        markdown_file = readonly_dir / "test.md"
+
+        with pytest.raises(PermissionError):
+            get_new_changelog_md(
+                domains=["enterprise-attack"],
+                markdown_file=str(markdown_file),
+                old=old_dir,
+                new=new_dir,
+                verbose=False,
+            )

tests/changelog/cli/test_argument_handling.py

@@ -0,0 +1,191 @@
+"""Tests for CLI argument parsing and validation."""
+
+import sys
+
+import pytest
+
+from mitreattack.diffStix.changelog_helper import get_parsed_args
+
+
+class TestArgumentHandling:
+    """Comprehensive tests for CLI argument parsing and validation."""
+
+    def _parse_args(self, argv_list, monkeypatch, setup_monkeypatch_args=None):
+        """Parse arguments with monkeypatch setup."""
+        if setup_monkeypatch_args:
+            setup_monkeypatch_args(argv_list, monkeypatch)
+        else:
+            monkeypatch.setattr(sys, "argv", argv_list)
+        return get_parsed_args()
+
+    def _expect_system_exit(self, argv_list, monkeypatch, expected_code=None):
+        """Test SystemExit scenarios."""
+        monkeypatch.setattr(sys, "argv", argv_list)
+        with pytest.raises(SystemExit) as exc_info:
+            get_parsed_args()
+        if expected_code is not None:
+            assert exc_info.value.code == expected_code
+        return exc_info
+
+    def _assert_default_args(self, args):
+        """Assert default argument values."""
+        assert args.old == "old"
+        assert args.new == "new"
+        assert args.domains == ["enterprise-attack", "mobile-attack", "ics-attack"]
+        assert args.unchanged is False
+        assert args.show_key is False
+        assert args.contributors is True
+        assert args.verbose is False
+        assert args.use_mitre_cti is False
+        assert args.site_prefix == ""
+
+    def test_get_parsed_args_default_values(self, monkeypatch):
+        """Test default argument values."""
+        args = self._parse_args(["script_name"], monkeypatch)
+        self._assert_default_args(args)
+
+    def test_get_parsed_args_all_options(self, monkeypatch):
+        """Test parsing with all command-line options specified."""
+        test_args = [
+            "script_name",
+            "--old",
+            "old_data",
+            "--new",
+            "new_data",
+            "--domains",
+            "enterprise-attack",
+            "--markdown-file",
+            "test.md",
+            "--html-file",
+            "test.html",
+            "--html-file-detailed",
+            "detailed.html",
+            "--json-file",
+            "test.json",
+            "--layers",
+            "layer1.json",
+            "layer2.json",
+            "layer3.json",
+            "--site_prefix",
+            "https://example.com",
+            "--unchanged",
+            "--show-key",
+            "--no-contributors",
+            "--verbose",
+        ]
+
+        args = self._parse_args(test_args, monkeypatch)
+
+        assert args.old == "old_data"
+        assert args.new == "new_data"
+        assert args.domains == ["enterprise-attack"]
+        assert args.markdown_file == "test.md"
+        assert args.html_file == "test.html"
+        assert args.html_file_detailed == "detailed.html"
+        assert args.json_file == "test.json"
+        assert args.layers == ["layer1.json", "layer2.json", "layer3.json"]
+        assert args.site_prefix == "https://example.com"
+        assert args.unchanged is True
+        assert args.show_key is True
+        assert args.contributors is False
+        assert args.verbose is True
+
+    @pytest.mark.parametrize(
+        "test_args,expected_exit_code,description",
+        [
+            (["script_name", "--old", "old_data", "--use-mitre-cti"], None, "mutually exclusive options"),
+            (["script_name", "--help"], 0, "help option"),
+            (["script_name", "--invalid-option"], None, "invalid option"),
+            (["script_name", "--old"], None, "missing required value"),
+        ],
+    )
+    def test_get_parsed_args_system_exit_scenarios(self, test_args, expected_exit_code, description, monkeypatch):
+        """Test various scenarios that should cause SystemExit."""
+        exc_info = self._expect_system_exit(test_args, monkeypatch, expected_exit_code)
+        if expected_exit_code is not None:
+            assert exc_info.value.code == expected_exit_code
+
+    @pytest.mark.parametrize(
+        "layers_input,expected_result,should_exit",
+        [
+            ([], [], False),  # Empty list is valid
+            (
+                ["enterprise.json", "mobile.json", "ics.json"],
+                ["enterprise.json", "mobile.json", "ics.json"],
+                False,
+            ),  # Three files is valid
+            (["layer1.json", "layer2.json"], None, True),  # Wrong count - need 0 or 3
+        ],
+    )
+    def test_get_parsed_args_layer_validation(self, layers_input, expected_result, should_exit, monkeypatch):
+        """Test layer argument validation scenarios."""
+        test_args = ["script_name", "--layers"] + layers_input
+
+        if should_exit:
+            self._expect_system_exit(test_args, monkeypatch)
+        else:
+            args = self._parse_args(test_args, monkeypatch)
+            assert args.layers == expected_result
+
+    def test_get_parsed_args_logging_configuration_verbose(self, monkeypatch):
+        """Test logging configuration in verbose mode."""
+        args = self._parse_args(["script_name", "--verbose"], monkeypatch)
+        assert args.verbose is True
+
+    def test_get_parsed_args_logging_configuration_normal(self, monkeypatch):
+        """Test logging configuration in normal mode."""
+        args = self._parse_args(["script_name"], monkeypatch)
+        assert args.verbose is False
+
+    @pytest.mark.parametrize(
+        "domains_input,expected_domains",
+        [
+            (["enterprise-attack"], ["enterprise-attack"]),
+            (["enterprise-attack", "mobile-attack"], ["enterprise-attack", "mobile-attack"]),
+            (
+                ["enterprise-attack", "mobile-attack", "ics-attack"],
+                ["enterprise-attack", "mobile-attack", "ics-attack"],
+            ),
+        ],
+    )
+    def test_get_parsed_args_domains(self, domains_input, expected_domains, monkeypatch):
+        """Test parsing with various domain configurations."""
+        test_args = ["script_name", "--domains"] + domains_input
+        args = self._parse_args(test_args, monkeypatch)
+        assert args.domains == expected_domains
+
+    @pytest.mark.parametrize(
+        "flag,expected_attr,expected_value",
+        [
+            ("--unchanged", "unchanged", True),
+            ("--show-key", "show_key", True),
+            ("--no-contributors", "contributors", False),
+            ("--verbose", "verbose", True),
+            ("--use-mitre-cti", "use_mitre_cti", True),
+        ],
+    )
+    def test_get_parsed_args_boolean_flags(self, flag, expected_attr, expected_value, monkeypatch):
+        """Test individual boolean flags."""
+        test_args = ["script_name", flag]
+        args = self._parse_args(test_args, monkeypatch)
+        assert getattr(args, expected_attr) == expected_value
+
+    @pytest.mark.parametrize(
+        "option,value,expected_attr",
+        [
+            ("--old", "custom_old", "old"),
+            ("--new", "custom_new", "new"),
+            ("--markdown-file", "custom.md", "markdown_file"),
+            ("--html-file", "custom.html", "html_file"),
+            ("--html-file-detailed", "detailed.html", "html_file_detailed"),
+            ("--json-file", "custom.json", "json_file"),
+            ("--site_prefix", "https://custom.com", "site_prefix"),
+            ("--site_prefix", "", "site_prefix"),  # Empty site prefix
+            ("--site_prefix", "https://example.com/", "site_prefix"),  # With trailing slash
+        ],
+    )
+    def test_get_parsed_args_string_options(self, option, value, expected_attr, monkeypatch):
+        """Test individual string options."""
+        test_args = ["script_name", option, value]
+        args = self._parse_args(test_args, monkeypatch)
+        assert getattr(args, expected_attr) == value