robojerk
c51819c836
- Add complete pytest testing framework with conftest.py and test files - Add performance monitoring and benchmarking capabilities - Add plugin system with ccache plugin example - Add comprehensive documentation (API, deployment, testing, etc.) - Add Docker API wrapper for service deployment - Add advanced configuration examples - Remove old wget package file - Update core modules with enhanced functionality
643 lines
28 KiB
Python
643 lines
28 KiB
Python
"""
|
|
Tests for deb-mock core functionality
|
|
"""
|
|
|
|
import pytest
|
|
import os
|
|
import tempfile
|
|
from unittest.mock import Mock, patch, MagicMock
|
|
|
|
from deb_mock.core import DebMock
|
|
from deb_mock.exceptions import DebMockError, ChrootError, CacheError
|
|
|
|
|
|
class TestDebMock:
|
|
"""Test the core DebMock class"""
|
|
|
|
def test_initialization(self, test_config):
|
|
"""Test DebMock initialization"""
|
|
deb_mock = DebMock(test_config)
|
|
|
|
assert deb_mock.config == test_config
|
|
assert deb_mock.chroot_manager is not None
|
|
assert deb_mock.cache_manager is not None
|
|
assert deb_mock.sbuild_wrapper is not None
|
|
assert deb_mock.plugin_manager is not None
|
|
assert deb_mock.performance_monitor is not None
|
|
|
|
def test_initialization_with_performance_monitoring(self, performance_test_config):
|
|
"""Test DebMock initialization with performance monitoring enabled"""
|
|
deb_mock = DebMock(performance_test_config)
|
|
|
|
assert deb_mock.performance_monitor.enable_monitoring is True
|
|
assert deb_mock.performance_optimizer is not None
|
|
assert deb_mock.performance_reporter is not None
|
|
|
|
def test_initialization_with_plugins(self, plugin_test_config):
|
|
"""Test DebMock initialization with plugins"""
|
|
deb_mock = DebMock(plugin_test_config)
|
|
|
|
assert deb_mock.plugin_manager is not None
|
|
# Plugin manager should be initialized
|
|
deb_mock.plugin_manager.init_plugins.assert_called_once_with(deb_mock)
|
|
|
|
@patch('deb_mock.core.ChrootManager')
|
|
@patch('deb_mock.core.CacheManager')
|
|
@patch('deb_mock.core.SbuildWrapper')
|
|
@patch('deb_mock.core.PluginManager')
|
|
@patch('deb_mock.core.PerformanceMonitor')
|
|
def test_component_initialization(self, mock_perf_mon, mock_plugin_mgr,
|
|
mock_sbuild, mock_cache_mgr, mock_chroot_mgr,
|
|
test_config):
|
|
"""Test that all components are properly initialized"""
|
|
deb_mock = DebMock(test_config)
|
|
|
|
# Verify all managers are created
|
|
mock_chroot_mgr.assert_called_once_with(test_config)
|
|
mock_cache_mgr.assert_called_once_with(test_config)
|
|
mock_sbuild.assert_called_once_with(test_config)
|
|
mock_plugin_mgr.assert_called_once_with(test_config)
|
|
mock_perf_mon.assert_called_once_with(test_config)
|
|
|
|
def test_build_with_existing_chroot(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with an existing chroot"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify chroot was not created
|
|
mock_chroot_manager.create_chroot.assert_not_called()
|
|
|
|
# Verify hooks were called
|
|
mock_plugin_manager.call_hooks.assert_any_call(
|
|
mock_plugin_manager.HookStages.PREBUILD, sample_source_package, chroot_name="test-chroot"
|
|
)
|
|
mock_plugin_manager.call_hooks.assert_any_call(
|
|
mock_plugin_manager.HookStages.BUILD_START, sample_source_package, "test-chroot"
|
|
)
|
|
mock_plugin_manager.call_hooks.assert_any_call(
|
|
mock_plugin_manager.HookStages.BUILD_END, result, sample_source_package, "test-chroot"
|
|
)
|
|
mock_plugin_manager.call_hooks.assert_any_call(
|
|
mock_plugin_manager.HookStages.POSTBUILD, result, sample_source_package
|
|
)
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_new_chroot(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with a new chroot"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot doesn't exist
|
|
mock_chroot_manager.chroot_exists.return_value = False
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify chroot was created
|
|
mock_chroot_manager.create_chroot.assert_called_once_with("test-chroot")
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_cache_restore(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with cache restoration"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot doesn't exist but cache restore succeeds
|
|
mock_chroot_manager.chroot_exists.return_value = False
|
|
mock_cache_manager.restore_root_cache.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify cache was restored
|
|
mock_cache_manager.restore_root_cache.assert_called_once()
|
|
|
|
# Verify chroot was not created (cache restore succeeded)
|
|
mock_chroot_manager.create_chroot.assert_not_called()
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_failed_cache_restore(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with failed cache restoration"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot doesn't exist and cache restore fails
|
|
mock_chroot_manager.chroot_exists.return_value = False
|
|
mock_cache_manager.restore_root_cache.return_value = False
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify cache restore was attempted
|
|
mock_cache_manager.restore_root_cache.assert_called_once()
|
|
|
|
# Verify chroot was created (cache restore failed)
|
|
mock_chroot_manager.create_chroot.assert_called_once_with("test-chroot")
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_custom_chroot_name(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with a custom chroot name"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/custom-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build with custom chroot name
|
|
result = mock_deb_mock.build(sample_source_package, chroot_name="custom-chroot")
|
|
|
|
# Verify custom chroot name was used
|
|
mock_chroot_manager.chroot_exists.assert_called_with("custom-chroot")
|
|
|
|
# Verify hooks were called with custom chroot name
|
|
mock_plugin_manager.call_hooks.assert_any_call(
|
|
mock_plugin_manager.HookStages.BUILD_START, sample_source_package, "custom-chroot"
|
|
)
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_keep_chroot(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with keep_chroot option"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
mock_deb_mock.config.keep_chroot = False # Default is False
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build with keep_chroot=True
|
|
result = mock_deb_mock.build(sample_source_package, keep_chroot=True)
|
|
|
|
# Verify chroot was not cleaned up
|
|
mock_chroot_manager.clean_chroot.assert_not_called()
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_without_keep_chroot(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building without keep_chroot option"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
mock_deb_mock.config.keep_chroot = False # Default is False
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build (default keep_chroot=False)
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify chroot was cleaned up
|
|
mock_chroot_manager.clean_chroot.assert_called_once_with("test-chroot")
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_successful_result(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with successful result triggers cache creation"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify cache was created (successful build)
|
|
mock_cache_manager.create_root_cache.assert_called_once()
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_failed_result(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building with failed result doesn't trigger cache creation"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock failed build result
|
|
mock_sbuild_wrapper.build_package.return_value = {
|
|
"success": False,
|
|
"error": "Build failed",
|
|
"output": "Error output"
|
|
}
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify cache was not created (failed build)
|
|
mock_cache_manager.create_root_cache.assert_not_called()
|
|
|
|
# Verify build result
|
|
assert result["success"] is False
|
|
assert "error" in result
|
|
|
|
def test_build_metadata_capture(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test that build metadata is captured and stored"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={"test": "data"})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = mock_deb_mock.build(sample_source_package)
|
|
|
|
# Verify metadata was captured
|
|
mock_deb_mock._capture_build_metadata.assert_called_once_with(result, sample_source_package)
|
|
|
|
# Verify metadata was stored
|
|
mock_deb_mock.metadata_manager.store_metadata.assert_called_once_with({"test": "data"})
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_performance_monitoring(self, performance_test_config, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager):
|
|
"""Test building with performance monitoring enabled"""
|
|
# Create DebMock with performance monitoring
|
|
deb_mock = DebMock(performance_test_config)
|
|
|
|
# Mock the components
|
|
deb_mock.chroot_manager = mock_chroot_manager
|
|
deb_mock.cache_manager = mock_cache_manager
|
|
deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
deb_mock.plugin_manager = mock_plugin_manager
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
deb_mock._capture_build_metadata = Mock(return_value={})
|
|
deb_mock.metadata_manager = Mock()
|
|
|
|
# Run build
|
|
result = deb_mock.build(sample_source_package)
|
|
|
|
# Verify performance monitoring was used
|
|
assert deb_mock.performance_monitor.create_build_profile.called
|
|
assert deb_mock.performance_monitor.finalize_build_profile.called
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_with_auto_optimization(self, performance_test_config, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager):
|
|
"""Test building with automatic optimization enabled"""
|
|
# Enable auto optimization
|
|
performance_test_config.performance_auto_optimization = True
|
|
|
|
# Create DebMock with performance monitoring and auto optimization
|
|
deb_mock = DebMock(performance_test_config)
|
|
|
|
# Mock the components
|
|
deb_mock.chroot_manager = mock_chroot_manager
|
|
deb_mock.cache_manager = mock_cache_manager
|
|
deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
deb_mock.plugin_manager = mock_plugin_manager
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
deb_mock._capture_build_metadata = Mock(return_value={})
|
|
deb_mock.metadata_manager = Mock()
|
|
|
|
# Mock performance analysis
|
|
mock_analysis = {
|
|
"automatic_tunings": [{"type": "parallel_builds", "suggested": 3}]
|
|
}
|
|
deb_mock.performance_optimizer.analyze_build_performance = Mock(return_value=mock_analysis)
|
|
|
|
# Run build
|
|
result = deb_mock.build(sample_source_package)
|
|
|
|
# Verify optimization analysis was performed
|
|
deb_mock.performance_optimizer.analyze_build_performance.assert_called_once()
|
|
|
|
# Verify build result
|
|
assert result["success"] is True
|
|
|
|
def test_build_chain(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building multiple packages in a chain"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Create multiple packages
|
|
packages = [sample_source_package, sample_source_package]
|
|
|
|
# Run build chain
|
|
results = mock_deb_mock.build_chain(packages)
|
|
|
|
# Verify all packages were built
|
|
assert len(results) == 2
|
|
assert all(result["success"] for result in results)
|
|
|
|
# Verify build was called for each package
|
|
assert mock_deb_mock.sbuild_wrapper.build_package.call_count == 2
|
|
|
|
def test_build_chain_with_failure(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test building chain stops on first failure"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Mock first build succeeds, second fails
|
|
mock_deb_mock.sbuild_wrapper.build_package.side_effect = [
|
|
{"success": True, "output": "First build succeeded"},
|
|
{"success": False, "error": "Second build failed"}
|
|
]
|
|
|
|
# Create multiple packages
|
|
packages = [sample_source_package, sample_source_package]
|
|
|
|
# Run build chain
|
|
results = mock_deb_mock.build_chain(packages)
|
|
|
|
# Verify only first package was built successfully
|
|
assert len(results) == 1
|
|
assert results[0]["success"] is True
|
|
|
|
# Verify build was called only once (stopped on failure)
|
|
assert mock_deb_mock.sbuild_wrapper.build_package.call_count == 2
|
|
|
|
def test_parallel_build(self, mock_deb_mock, sample_source_package,
|
|
mock_chroot_manager, mock_cache_manager,
|
|
mock_sbuild_wrapper, mock_plugin_manager,
|
|
mock_performance_monitor):
|
|
"""Test parallel building of packages"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
mock_deb_mock.sbuild_wrapper = mock_sbuild_wrapper
|
|
mock_deb_mock.plugin_manager = mock_plugin_manager
|
|
mock_deb_mock.performance_monitor = mock_performance_monitor
|
|
|
|
# Mock chroot exists
|
|
mock_chroot_manager.chroot_exists.return_value = True
|
|
|
|
# Mock config methods
|
|
mock_deb_mock.config.setup_build_environment = Mock(return_value={})
|
|
mock_deb_mock.config.get_chroot_path = Mock(return_value="/tmp/test-chroot")
|
|
mock_deb_mock.config.parallel_builds = 2
|
|
|
|
# Mock metadata methods
|
|
mock_deb_mock._capture_build_metadata = Mock(return_value={})
|
|
mock_deb_mock.metadata_manager = Mock()
|
|
|
|
# Create multiple packages
|
|
packages = [sample_source_package, sample_source_package, sample_source_package]
|
|
|
|
# Run parallel build
|
|
results = mock_deb_mock.build_parallel(packages)
|
|
|
|
# Verify all packages were built
|
|
assert len(results) == 3
|
|
assert all(result["success"] for result in results)
|
|
|
|
# Verify build was called for each package
|
|
assert mock_deb_mock.sbuild_wrapper.build_package.call_count == 3
|
|
|
|
def test_cleanup(self, mock_deb_mock, mock_chroot_manager, mock_cache_manager):
|
|
"""Test cleanup functionality"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
|
|
# Run cleanup
|
|
mock_deb_mock.cleanup()
|
|
|
|
# Verify cleanup was called on managers
|
|
mock_chroot_manager.cleanup.assert_called_once()
|
|
mock_cache_manager.cleanup.assert_called_once()
|
|
|
|
def test_get_status(self, mock_deb_mock, mock_chroot_manager, mock_cache_manager):
|
|
"""Test status reporting"""
|
|
# Mock the components
|
|
mock_deb_mock.chroot_manager = mock_chroot_manager
|
|
mock_deb_mock.cache_manager = mock_cache_manager
|
|
|
|
# Mock status methods
|
|
mock_chroot_manager.get_status.return_value = {"chroots": 2, "active": 1}
|
|
mock_cache_manager.get_status.return_value = {"caches": 3, "size_mb": 1024}
|
|
|
|
# Get status
|
|
status = mock_deb_mock.get_status()
|
|
|
|
# Verify status includes all components
|
|
assert "chroot_manager" in status
|
|
assert "cache_manager" in status
|
|
assert status["chroot_manager"]["chroots"] == 2
|
|
assert status["cache_manager"]["caches"] == 3
|