runbooks 0.2.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

runbooks/cfat/tests/test_cli.py

@@ -0,0 +1,340 @@
+"""
+CLI tests for Cloud Foundations Assessment Tool.
+
+Tests command-line interface argument parsing, validation, and integration
+with the assessment engine. These tests focus on CLI behavior separately
+from AWS API interactions.
+"""
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from runbooks.cfat.tests import create_sample_assessment_report
+from runbooks.main import assess, cfat, main
+
+
+@pytest.mark.cli
+class TestCFATCLI:
+    """Test CFAT CLI functionality."""
+
+    def setup_method(self):
+        """Set up test environment."""
+        self.runner = CliRunner()
+        self.sample_report = create_sample_assessment_report()
+
+    def test_cfat_help_command(self):
+        """Test CFAT help command."""
+        result = self.runner.invoke(main, ["cfat", "--help"])
+
+        assert result.exit_code == 0
+        assert "Cloud Foundations Assessment Tool" in result.output
+        assert "assess" in result.output
+
+    def test_assess_help_command(self):
+        """Test assess command help."""
+        result = self.runner.invoke(main, ["cfat", "assess", "--help"])
+
+        assert result.exit_code == 0
+        assert "Run enhanced Cloud Foundations assessment" in result.output
+        assert "--output" in result.output
+        assert "--severity" in result.output
+        assert "--parallel" in result.output
+        assert "--export-jira" in result.output
+
+    def test_assess_basic_arguments(self):
+        """Test basic assess command arguments."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(main, ["cfat", "assess", "--output", "console", "--severity", "WARNING"])
+
+            # Should complete successfully
+            assert result.exit_code == 0
+
+            # Verify runner was initialized and configured
+            mock_runner.assert_called_once()
+            mock_instance.set_min_severity.assert_called_with("WARNING")
+            mock_instance.run_assessment.assert_called_once()
+
+    def test_assess_output_formats(self):
+        """Test different output formats."""
+        formats = ["console", "html", "csv", "json", "markdown"]
+
+        for format_type in formats:
+            with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+                mock_instance = MagicMock()
+                mock_instance.run_assessment.return_value = self.sample_report
+                mock_runner.return_value = mock_instance
+
+                result = self.runner.invoke(main, ["cfat", "assess", "--output", format_type])
+
+                assert result.exit_code == 0, f"Failed for format: {format_type}"
+
+    def test_assess_all_output_format(self):
+        """Test 'all' output format generates multiple files."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+                original_cwd = os.getcwd()
+                try:
+                    os.chdir(temp_dir)
+
+                    result = self.runner.invoke(main, ["cfat", "assess", "--output", "all"])
+
+                    assert result.exit_code == 0
+                    assert "Generated files:" in result.output
+
+                finally:
+                    os.chdir(original_cwd)
+
+    def test_assess_specific_checks(self):
+        """Test specifying specific checks to run."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(
+                main, ["cfat", "assess", "--checks", "iam_root_mfa", "--checks", "cloudtrail_enabled"]
+            )
+
+            assert result.exit_code == 0
+            mock_instance.set_checks.assert_called_with(["iam_root_mfa", "cloudtrail_enabled"])
+
+    def test_assess_skip_checks(self):
+        """Test skipping specific checks."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(
+                main, ["cfat", "assess", "--skip-checks", "ec2_instances", "--skip-checks", "rds_instances"]
+            )
+
+            assert result.exit_code == 0
+            mock_instance.skip_checks.assert_called_with(["ec2_instances", "rds_instances"])
+
+    def test_assess_categories(self):
+        """Test specifying assessment categories."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_instance.assessment_config = MagicMock()
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(
+                main, ["cfat", "assess", "--categories", "iam", "--categories", "vpc", "--skip-categories", "ec2"]
+            )
+
+            assert result.exit_code == 0
+
+            # Verify categories were set
+            assert mock_instance.assessment_config.included_categories == ["iam", "vpc"]
+            assert mock_instance.assessment_config.excluded_categories == ["ec2"]
+
+    def test_assess_parallel_execution_options(self):
+        """Test parallel execution configuration."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_instance.assessment_config = MagicMock()
+            mock_runner.return_value = mock_instance
+
+            # Test parallel execution
+            result = self.runner.invoke(main, ["cfat", "assess", "--parallel", "--max-workers", "5"])
+
+            assert result.exit_code == 0
+            assert mock_instance.assessment_config.parallel_execution is True
+            assert mock_instance.assessment_config.max_workers == 5
+
+            # Test sequential execution
+            result = self.runner.invoke(main, ["cfat", "assess", "--sequential"])
+
+            assert result.exit_code == 0
+            assert mock_instance.assessment_config.parallel_execution is False
+
+    def test_assess_compliance_framework(self):
+        """Test compliance framework specification."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_instance.assessment_config = MagicMock()
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(main, ["cfat", "assess", "--compliance-framework", "SOC2"])
+
+            assert result.exit_code == 0
+            assert mock_instance.assessment_config.compliance_framework == "SOC2"
+
+    def test_assess_export_integrations(self):
+        """Test export to project management tools."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            with patch("runbooks.cfat.reporting.exporters.JiraExporter") as mock_jira:
+                with patch("runbooks.cfat.reporting.exporters.AsanaExporter") as mock_asana:
+                    mock_instance = MagicMock()
+                    mock_instance.run_assessment.return_value = self.sample_report
+                    mock_runner.return_value = mock_instance
+
+                    mock_jira_instance = MagicMock()
+                    mock_asana_instance = MagicMock()
+                    mock_jira.return_value = mock_jira_instance
+                    mock_asana.return_value = mock_asana_instance
+
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        jira_file = os.path.join(temp_dir, "jira.csv")
+                        asana_file = os.path.join(temp_dir, "asana.csv")
+
+                        result = self.runner.invoke(
+                            main, ["cfat", "assess", "--export-jira", jira_file, "--export-asana", asana_file]
+                        )
+
+                        assert result.exit_code == 0
+
+                        # Verify exporters were called
+                        mock_jira_instance.export.assert_called_once_with(self.sample_report, jira_file)
+                        mock_asana_instance.export.assert_called_once_with(self.sample_report, asana_file)
+
+    def test_assess_web_server_option(self):
+        """Test web server option (without actually starting server)."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            with patch("runbooks.main.start_web_server") as mock_web_server:
+                mock_instance = MagicMock()
+                mock_instance.run_assessment.return_value = self.sample_report
+                mock_runner.return_value = mock_instance
+
+                result = self.runner.invoke(main, ["cfat", "assess", "--serve-web", "--web-port", "9000"])
+
+                assert result.exit_code == 0
+                mock_web_server.assert_called_once_with(self.sample_report, 9000)
+
+    def test_assess_output_file_specification(self):
+        """Test specifying custom output file."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+                output_file = os.path.join(temp_dir, "custom_report.html")
+
+                result = self.runner.invoke(main, ["cfat", "assess", "--output", "html", "--output-file", output_file])
+
+                assert result.exit_code == 0
+
+    def test_assess_invalid_arguments(self):
+        """Test handling of invalid arguments."""
+        # Test invalid output format
+        result = self.runner.invoke(main, ["cfat", "assess", "--output", "invalid_format"])
+        assert result.exit_code != 0
+
+        # Test invalid severity
+        result = self.runner.invoke(main, ["cfat", "assess", "--severity", "INVALID"])
+        assert result.exit_code != 0
+
+        # Test invalid max-workers
+        result = self.runner.invoke(main, ["cfat", "assess", "--max-workers", "0"])
+        # This should succeed at CLI level but may fail in assessment config validation
+        assert result.exit_code in [0, 1]  # Either CLI rejects or assessment validates
+
+    def test_assess_error_handling(self):
+        """Test CLI error handling when assessment fails."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.side_effect = Exception("Assessment failed")
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(main, ["cfat", "assess"])
+
+            assert result.exit_code == 1
+            assert "Assessment failed" in result.output
+
+    def test_profile_and_region_options(self):
+        """Test AWS profile and region options."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(main, ["--profile", "test-profile", "--region", "eu-west-1", "cfat", "assess"])
+
+            assert result.exit_code == 0
+
+            # Verify runner was initialized with correct profile and region
+            mock_runner.assert_called_once()
+            call_args = mock_runner.call_args
+            assert call_args[1]["profile"] == "test-profile"
+            assert call_args[1]["region"] == "eu-west-1"
+
+    def test_debug_mode(self):
+        """Test debug mode activation."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            mock_instance = MagicMock()
+            mock_instance.run_assessment.return_value = self.sample_report
+            mock_runner.return_value = mock_instance
+
+            result = self.runner.invoke(main, ["--debug", "cfat", "assess"])
+
+            assert result.exit_code == 0
+
+    def test_comprehensive_cli_workflow(self):
+        """Test comprehensive CLI workflow with multiple options."""
+        with patch("runbooks.cfat.runner.AssessmentRunner") as mock_runner:
+            with patch("runbooks.cfat.reporting.exporters.JiraExporter") as mock_jira:
+                mock_instance = MagicMock()
+                mock_instance.run_assessment.return_value = self.sample_report
+                mock_instance.assessment_config = MagicMock()
+                mock_runner.return_value = mock_instance
+
+                mock_jira_instance = MagicMock()
+                mock_jira.return_value = mock_jira_instance
+
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    jira_file = os.path.join(temp_dir, "jira_export.csv")
+
+                    result = self.runner.invoke(
+                        main,
+                        [
+                            "--profile",
+                            "production",
+                            "--region",
+                            "us-west-2",
+                            "--debug",
+                            "cfat",
+                            "assess",
+                            "--output",
+                            "all",
+                            "--categories",
+                            "iam",
+                            "cloudtrail",
+                            "--skip-checks",
+                            "ec2_unused_instances",
+                            "--severity",
+                            "CRITICAL",
+                            "--parallel",
+                            "--max-workers",
+                            "8",
+                            "--compliance-framework",
+                            "SOC2",
+                            "--export-jira",
+                            jira_file,
+                        ],
+                    )
+
+                    assert result.exit_code == 0
+
+                    # Verify all configurations were applied
+                    assert mock_instance.assessment_config.included_categories == ["iam", "cloudtrail"]
+                    assert mock_instance.assessment_config.excluded_checks == ["ec2_unused_instances"]
+                    assert mock_instance.assessment_config.parallel_execution is True
+                    assert mock_instance.assessment_config.max_workers == 8
+                    assert mock_instance.assessment_config.compliance_framework == "SOC2"

runbooks/cfat/tests/test_integration.py

@@ -0,0 +1,290 @@
+"""
+Integration tests for Cloud Foundations Assessment Tool.
+
+Tests the complete CFAT workflow using moto for AWS service mocking,
+ensuring the assessment engine works correctly with AWS APIs without
+requiring real AWS credentials or making actual API calls.
+
+These tests focus on integration patterns and real-world usage scenarios
+while maintaining fast execution and reliability.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import boto3
+import pytest
+from moto import mock_aws
+
+from runbooks.cfat.assessment.runner import CloudFoundationsAssessment
+from runbooks.cfat.models import AssessmentConfig, CheckStatus, Severity
+from runbooks.cfat.tests import TEST_ACCOUNT_ID, TEST_PROFILE, TEST_REGION
+
+
+@pytest.mark.integration
+class TestCFATIntegrationWithMoto:
+    """Integration tests using moto for AWS service mocking."""
+
+    @mock_aws
+    def test_iam_assessment_with_mock_services(self):
+        """Test IAM assessment using moto-mocked AWS services."""
+        # Create mock IAM resources
+        iam_client = boto3.client("iam", region_name=TEST_REGION)
+
+        # Create test user
+        iam_client.create_user(UserName="test-user")
+
+        # Create test role
+        assume_role_policy = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {"Effect": "Allow", "Principal": {"Service": "ec2.amazonaws.com"}, "Action": "sts:AssumeRole"}
+            ],
+        }
+        iam_client.create_role(RoleName="test-role", AssumeRolePolicyDocument=str(assume_role_policy))
+
+        # Create test policy
+        policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}],
+        }
+        iam_client.create_policy(PolicyName="test-policy", PolicyDocument=str(policy_document))
+
+        # Mock the assessment runner to use our mocked services
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            # Initialize assessment
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            # Configure for IAM-only assessment
+            assessment.assessment_config.included_categories = ["iam"]
+            assessment.assessment_config.parallel_execution = False  # Easier to debug
+
+            # Run assessment
+            report = assessment.run_assessment()
+
+            # Validate results
+            assert report is not None
+            assert report.account_id == TEST_ACCOUNT_ID
+            assert report.region == TEST_REGION
+            assert len(report.results) > 0
+
+            # Should have IAM-related results
+            iam_results = report.get_results_by_category("iam")
+            assert len(iam_results) > 0
+
+            # Verify result structure
+            for result in iam_results:
+                assert result.finding_id is not None
+                assert result.check_name is not None
+                assert result.check_category == "iam"
+                assert result.status in [CheckStatus.PASS, CheckStatus.FAIL, CheckStatus.ERROR]
+                assert result.severity in [Severity.INFO, Severity.WARNING, Severity.CRITICAL]
+                assert result.execution_time >= 0
+
+    @mock_aws
+    def test_vpc_assessment_with_mock_services(self):
+        """Test VPC assessment using moto-mocked EC2 services."""
+        # Create mock VPC resources
+        ec2_client = boto3.client("ec2", region_name=TEST_REGION)
+
+        # Create VPC
+        vpc_response = ec2_client.create_vpc(CidrBlock="10.0.0.0/16")
+        vpc_id = vpc_response["Vpc"]["VpcId"]
+
+        # Create subnet
+        ec2_client.create_subnet(VpcId=vpc_id, CidrBlock="10.0.1.0/24")
+
+        # Create security group
+        ec2_client.create_security_group(GroupName="test-sg", Description="Test security group", VpcId=vpc_id)
+
+        # Mock assessment execution
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            # Configure for VPC-only assessment
+            assessment.assessment_config.included_categories = ["vpc"]
+            assessment.assessment_config.parallel_execution = False
+
+            report = assessment.run_assessment()
+
+            # Validate VPC assessment results
+            assert report is not None
+            vpc_results = report.get_results_by_category("vpc")
+
+            # Should have some VPC-related checks
+            assert len(vpc_results) >= 0  # May be 0 if no VPC checks implemented yet
+
+    @mock_aws
+    def test_cloudtrail_assessment_with_mock_services(self):
+        """Test CloudTrail assessment using moto-mocked services."""
+        # Create mock CloudTrail
+        cloudtrail_client = boto3.client("cloudtrail", region_name=TEST_REGION)
+
+        # Create trail
+        trail_name = "test-trail"
+        s3_bucket = "test-cloudtrail-bucket"
+
+        cloudtrail_client.create_trail(Name=trail_name, S3BucketName=s3_bucket)
+
+        # Start logging
+        cloudtrail_client.start_logging(Name=trail_name)
+
+        # Mock assessment
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            assessment.assessment_config.included_categories = ["cloudtrail"]
+            assessment.assessment_config.parallel_execution = False
+
+            report = assessment.run_assessment()
+
+            assert report is not None
+            cloudtrail_results = report.get_results_by_category("cloudtrail")
+            assert len(cloudtrail_results) >= 0
+
+    def test_assessment_configuration_integration(self):
+        """Test assessment configuration integration."""
+        # Test custom configuration
+        config = AssessmentConfig(
+            included_categories=["iam", "vpc"],
+            excluded_checks=["iam_unused_credentials"],
+            parallel_execution=True,
+            max_workers=5,
+            severity_threshold=Severity.WARNING,
+            compliance_framework="SOC2",
+        )
+
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+            assessment.assessment_config = config
+
+            # Should be able to run without errors
+            report = assessment.run_assessment()
+            assert report is not None
+            assert report.metadata.get("max_workers") == 5
+
+    def test_parallel_vs_sequential_execution(self):
+        """Test parallel vs sequential execution modes."""
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            # Test parallel execution
+            assessment_parallel = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+            assessment_parallel.assessment_config.parallel_execution = True
+            assessment_parallel.assessment_config.max_workers = 3
+
+            report_parallel = assessment_parallel.run_assessment()
+
+            # Test sequential execution
+            assessment_sequential = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+            assessment_sequential.assessment_config.parallel_execution = False
+
+            report_sequential = assessment_sequential.run_assessment()
+
+            # Both should produce valid reports
+            assert report_parallel is not None
+            assert report_sequential is not None
+
+            # Results should be similar (may vary due to mock timing)
+            assert len(report_parallel.results) > 0
+            assert len(report_sequential.results) > 0
+
+    def test_error_handling_in_assessment(self):
+        """Test error handling during assessment execution."""
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            # Mock a check that raises an exception
+            original_execute_single_check = assessment._execute_single_check
+
+            def mock_execute_single_check(check_name):
+                if check_name == "failing_check":
+                    raise Exception("Simulated check failure")
+                return original_execute_single_check(check_name)
+
+            assessment._execute_single_check = mock_execute_single_check
+
+            # Override available checks to include our failing check
+            assessment._available_checks = {"passing_check": "PassingCheck", "failing_check": "FailingCheck"}
+
+            # Run assessment
+            report = assessment.run_assessment()
+
+            # Should handle errors gracefully
+            assert report is not None
+
+            # Should have error results for failed checks
+            error_results = [r for r in report.results if r.status == CheckStatus.ERROR]
+            assert len(error_results) > 0
+
+    def test_report_generation_all_formats(self):
+        """Test report generation in all supported formats."""
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            # Run assessment
+            report = assessment.run_assessment()
+
+            # Test all export formats (without actually writing files)
+            assert hasattr(report, "to_json")
+            assert hasattr(report, "to_csv")
+            assert hasattr(report, "to_html")
+            assert hasattr(report, "to_markdown")
+
+            # Test methods return without error
+            assert callable(report.to_json)
+            assert callable(report.to_csv)
+            assert callable(report.to_html)
+            assert callable(report.to_markdown)
+
+    def test_compliance_framework_integration(self):
+        """Test compliance framework-specific assessments."""
+        frameworks = ["SOC2", "PCI-DSS", "HIPAA"]
+
+        for framework in frameworks:
+            with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+                mock_account.return_value = TEST_ACCOUNT_ID
+
+                assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+                assessment.assessment_config.compliance_framework = framework
+
+                report = assessment.run_assessment()
+
+                assert report is not None
+                assert (
+                    report.metadata.get("compliance_framework") is None
+                    or report.metadata.get("compliance_framework") == framework
+                )
+
+    @pytest.mark.slow
+    def test_large_scale_assessment(self):
+        """Test assessment with many checks (performance test)."""
+        with patch("runbooks.cfat.assessment.runner.CloudFoundationsAssessment.get_account_id") as mock_account:
+            mock_account.return_value = TEST_ACCOUNT_ID
+
+            assessment = CloudFoundationsAssessment(profile=TEST_PROFILE, region=TEST_REGION)
+
+            # Override with many mock checks
+            many_checks = {f"check_{i}": f"Check{i}" for i in range(50)}
+            assessment._available_checks = many_checks
+
+            assessment.assessment_config.parallel_execution = True
+            assessment.assessment_config.max_workers = 10
+
+            report = assessment.run_assessment()
+
+            assert report is not None
+            # Should complete in reasonable time with parallel execution
+            assert report.summary.total_execution_time < 60  # Should finish within 60 seconds
+            assert len(report.results) == 50