""" Comprehensive Unit Tests for Analytics and Reporting Services This module contains unit tests for analytics calculations, reporting functionality, and data integrity validation. """ from django.test import TestCase, TransactionTestCase from django.utils import timezone from django.contrib.auth import get_user_model from unittest.mock import patch, MagicMock, call from decimal import Decimal from datetime import date, timedelta import json from users.models import Branch from users.enhanced_permissions_models import PortfolioSnapshot, ClientGrowthMetrics from users.portfolio_snapshot_service import PortfolioSnapshotService from users.client_growth_analytics import ClientGrowthAnalytics from users.growth_forecasting_service import GrowthForecastingService from reports.enhanced_pdf_service import EnhancedPDFService from reports.export_functions import ExportService from reports.advanced_filtering_service import AdvancedFilteringService from reports.batch_processing_service import BatchProcessingService User = get_user_model() class PortfolioAnalyticsTest(TestCase): """Test cases for portfolio analytics calculations""" def setUp(self): """Set up test data""" self.branch = Branch.objects.create( name="Test Branch", code="TB001", is_active=True ) self.loan_officer = User.objects.create_user( username="officer1", email="officer1@test.com", password="testpass123", role="loan_officer", branch=self.branch, phone_number="+254700000002" ) self.service = PortfolioSnapshotService() def test_portfolio_metrics_calculation(self): """Test portfolio metrics calculation accuracy""" target_date = timezone.now().date() # Create test snapshots with known values snapshot1 = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=target_date, total_clients=10, active_clients=9, active_loans=8, total_disbursed=Decimal('100000.00'), total_outstanding=Decimal('60000.00'), total_collected=Decimal('40000.00'), collection_rate=Decimal('85.00'), default_rate=Decimal('5.00'), portfolio_yield=Decimal('12.00') ) # Test health score calculation health_score = snapshot1.get_portfolio_health_score() # Health score should be calculated correctly self.assertIsInstance(health_score, Decimal) self.assertGreaterEqual(health_score, 0) self.assertLessEqual(health_score, 100) # Test with good metrics - should have high health score self.assertGreater(health_score, 70) def test_portfolio_health_score_edge_cases(self): """Test portfolio health score with edge cases""" target_date = timezone.now().date() # Test with zero values snapshot_zero = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=target_date, total_clients=0, collection_rate=Decimal('0.00'), default_rate=Decimal('0.00'), portfolio_yield=Decimal('0.00') ) health_score = snapshot_zero.get_portfolio_health_score() self.assertGreaterEqual(health_score, 0) # Test with poor metrics snapshot_poor = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=target_date - timedelta(days=1), total_clients=10, collection_rate=Decimal('50.00'), # Poor collection default_rate=Decimal('20.00'), # High default rate portfolio_yield=Decimal('5.00') # Low yield ) health_score_poor = snapshot_poor.get_portfolio_health_score() self.assertLess(health_score_poor, 50) # Should be low def test_growth_rate_calculation(self): """Test growth rate calculation accuracy""" today = timezone.now().date() past_date = today - timedelta(days=30) # Create snapshots for growth calculation snapshot_past = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=past_date, total_clients=8, active_loans=6, total_disbursed=Decimal('80000.00') ) snapshot_current = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=today, total_clients=10, active_loans=8, total_disbursed=Decimal('100000.00') ) # Test client growth rate client_growth = snapshot_current.calculate_growth_rate(snapshot_past, 'total_clients') self.assertEqual(client_growth, Decimal('25.00')) # (10-8)/8 * 100 # Test loan growth rate loan_growth = snapshot_current.calculate_growth_rate(snapshot_past, 'active_loans') self.assertEqual(loan_growth, Decimal('33.33')) # (8-6)/6 * 100 # Test disbursement growth rate disbursement_growth = snapshot_current.calculate_growth_rate(snapshot_past, 'total_disbursed') self.assertEqual(disbursement_growth, Decimal('25.00')) # (100000-80000)/80000 * 100 def test_portfolio_trends_analysis(self): """Test portfolio trends analysis""" base_date = timezone.now().date() # Create multiple snapshots over time for i in range(7): # 7 days of data snapshot_date = base_date - timedelta(days=i) PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=snapshot_date, total_clients=10 + i, active_loans=8 + i, total_disbursed=Decimal(str(50000 + (i * 5000))), collection_rate=Decimal('85.00') + Decimal(str(i)), default_rate=Decimal('5.00') - Decimal(str(i * 0.5)) ) # Get trends trends = self.service.get_portfolio_trends(self.loan_officer, 7) # Verify trends structure self.assertIn('period', trends) self.assertIn('client_growth', trends) self.assertIn('loan_growth', trends) self.assertIn('daily_data', trends) self.assertEqual(len(trends['daily_data']), 7) # Verify trend calculations self.assertIsInstance(trends['client_growth'], (int, float, Decimal)) self.assertIsInstance(trends['loan_growth'], (int, float, Decimal)) def test_performance_alerts_generation(self): """Test performance alerts generation""" target_date = timezone.now().date() # Create snapshot with poor performance snapshot = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=target_date, total_clients=10, collection_rate=Decimal('60.00'), # Poor collection rate default_rate=Decimal('15.00'), # High default rate total_outstanding=Decimal('50000.00'), par_30=Decimal('10000.00') # High PAR ) health_score = Decimal('35.00') # Critical health score # Mock notification creation with patch('users.portfolio_snapshot_service.Notification') as mock_notification: with patch.object(self.service, '_send_alert_email') as mock_email: self.service._check_performance_alerts(self.loan_officer, snapshot, health_score) # Verify alerts were generated self.assertTrue(mock_notification.objects.create.called) self.assertTrue(mock_email.called) def test_portfolio_comparison_metrics(self): """Test portfolio comparison between managers""" # Create another loan officer officer2 = User.objects.create_user( username="officer2", email="officer2@test.com", password="testpass123", role="loan_officer", branch=self.branch, phone_number="+254700000003" ) target_date = timezone.now().date() # Create snapshots for both officers snapshot1 = PortfolioSnapshot.objects.create( manager=self.loan_officer, branch=self.branch, snapshot_date=target_date, total_clients=10, collection_rate=Decimal('85.00'), default_rate=Decimal('5.00') ) snapshot2 = PortfolioSnapshot.objects.create( manager=officer2, branch=self.branch, snapshot_date=target_date, total_clients=15, collection_rate=Decimal('90.00'), default_rate=Decimal('3.00') ) # Get comparison metrics comparison = self.service.get_portfolio_comparison([self.loan_officer, officer2], target_date) # Verify comparison structure self.assertIn('managers', comparison) self.assertIn('metrics', comparison) self.assertEqual(len(comparison['managers']), 2) # Verify ranking self.assertIn('ranking', comparison) self.assertIsInstance(comparison['ranking'], list) class ClientGrowthAnalyticsTest(TestCase): """Test cases for client growth analytics""" def setUp(self): """Set up test data""" self.branch = Branch.objects.create( name="Test Branch", code="TB001", is_active=True ) self.loan_officer = User.objects.create_user( username="officer1", email="officer1@test.com", password="testpass123", role="loan_officer", branch=self.branch, phone_number="+254700000002" ) self.analytics_service = ClientGrowthAnalytics() def test_client_acquisition_trends(self): """Test client acquisition trends calculation""" # Create test client growth metrics base_date = timezone.now().date() for i in range(6): # 6 months of data month_start = base_date.replace(day=1) - timedelta(days=30*i) month_end = month_start + timedelta(days=29) ClientGrowthMetrics.objects.create( branch=self.branch, period_start=month_start, period_end=month_end, new_clients=10 + i, churned_clients=2, reactivated_clients=1, total_clients=50 + (i * 8), acquisition_cost=Decimal('500.00'), lifetime_value=Decimal('2000.00') ) # Get acquisition trends trends = self.analytics_service.get_acquisition_trends(self.branch.id, 6) # Verify trends structure self.assertIn('period_months', trends) self.assertIn('monthly_data', trends) self.assertIn('total_acquired', trends) self.assertIn('average_monthly', trends) self.assertEqual(len(trends['monthly_data']), 6) def test_demographic_analysis(self): """Test client demographic analysis""" # Mock client data for demographic analysis with patch.object(self.analytics_service, '_get_client_demographics') as mock_demographics: mock_demographics.return_value = { 'age_groups': { '18-25': 20, '26-35': 35, '36-45': 30, '46+': 15 }, 'gender': { 'male': 60, 'female': 40 }, 'income_brackets': { 'low': 25, 'medium': 50, 'high': 25 } } # Get demographic analysis demographics = self.analytics_service.get_demographic_analysis({'branch_id': self.branch.id}) # Verify demographic structure self.assertIn('age_groups', demographics) self.assertIn('gender', demographics) self.assertIn('income_brackets', demographics) # Verify percentages add up correctly age_total = sum(demographics['age_groups'].values()) self.assertEqual(age_total, 100) def test_lifecycle_analytics(self): """Test client lifecycle analytics""" # Mock lifecycle data with patch.object(self.analytics_service, '_calculate_lifecycle_metrics') as mock_lifecycle: mock_lifecycle.return_value = { 'average_lifespan_days': 365, 'stages': { 'new': {'count': 20, 'avg_duration_days': 30}, 'active': {'count': 60, 'avg_duration_days': 300}, 'dormant': {'count': 15, 'avg_duration_days': 90}, 'churned': {'count': 5, 'avg_duration_days': 0} }, 'conversion_rates': { 'new_to_active': 85.0, 'active_to_dormant': 20.0, 'dormant_to_churned': 30.0 } } # Get lifecycle analytics lifecycle = self.analytics_service.get_lifecycle_analytics('active_clients') # Verify lifecycle structure self.assertIn('average_lifespan_days', lifecycle) self.assertIn('stages', lifecycle) self.assertIn('conversion_rates', lifecycle) # Verify conversion rates are percentages for rate in lifecycle['conversion_rates'].values(): self.assertGreaterEqual(rate, 0) self.assertLessEqual(rate, 100) def test_officer_performance_metrics(self): """Test loan officer performance metrics""" # Create test data for officer performance target_date = timezone.now().date() # Mock performance data with patch.object(self.analytics_service, '_calculate_officer_metrics') as mock_metrics: mock_metrics.return_value = { 'client_acquisition': { 'new_clients': 15, 'acquisition_rate': 12.5, 'conversion_rate': 85.0 }, 'portfolio_performance': { 'total_clients': 120, 'active_clients': 110, 'retention_rate': 91.7 }, 'loan_performance': { 'loans_disbursed': 25, 'approval_rate': 78.0, 'default_rate': 4.2 }, 'collection_performance': { 'collection_rate': 88.5, 'recovery_rate': 92.0 } } # Get officer performance performance = self.analytics_service.get_officer_performance(self.loan_officer.id, 30) # Verify performance structure self.assertIn('client_acquisition', performance) self.assertIn('portfolio_performance', performance) self.assertIn('loan_performance', performance) self.assertIn('collection_performance', performance) # Verify metrics are reasonable self.assertGreaterEqual(performance['portfolio_performance']['retention_rate'], 0) self.assertLessEqual(performance['portfolio_performance']['retention_rate'], 100) def test_growth_forecasting(self): """Test growth forecasting calculations""" # Create historical data for forecasting base_date = timezone.now().date() for i in range(12): # 12 months of historical data month_start = base_date.replace(day=1) - timedelta(days=30*i) month_end = month_start + timedelta(days=29) ClientGrowthMetrics.objects.create( branch=self.branch, period_start=month_start, period_end=month_end, new_clients=10 + (i % 3), # Seasonal pattern total_clients=100 + (i * 5), acquisition_cost=Decimal('500.00'), lifetime_value=Decimal('2000.00') ) forecasting_service = GrowthForecastingService() # Get growth forecast forecast = forecasting_service.generate_growth_forecast(self.branch.id, 6) # 6 months ahead # Verify forecast structure self.assertIn('forecast_period', forecast) self.assertIn('predicted_growth', forecast) self.assertIn('confidence_interval', forecast) self.assertIn('seasonal_factors', forecast) # Verify forecast data self.assertEqual(forecast['forecast_period'], 6) self.assertIsInstance(forecast['predicted_growth'], list) self.assertEqual(len(forecast['predicted_growth']), 6) def test_capacity_planning(self): """Test capacity planning calculations""" forecasting_service = GrowthForecastingService() # Mock current capacity data current_capacity = { 'loan_officers': 5, 'max_clients_per_officer': 50, 'current_utilization': 0.8 } # Mock growth projection growth_projection = { 'new_clients_per_month': 15, 'forecast_months': 12 } # Calculate capacity requirements capacity_plan = forecasting_service.calculate_capacity_requirements( current_capacity, growth_projection ) # Verify capacity plan structure self.assertIn('current_capacity', capacity_plan) self.assertIn('projected_demand', capacity_plan) self.assertIn('capacity_gap', capacity_plan) self.assertIn('recommendations', capacity_plan) # Verify calculations projected_clients = growth_projection['new_clients_per_month'] * growth_projection['forecast_months'] self.assertGreater(capacity_plan['projected_demand'], 0) class ReportGenerationTest(TestCase): """Test cases for report generation and export functionality""" def setUp(self): """Set up test data""" self.branch = Branch.objects.create( name="Test Branch", code="TB001", is_active=True ) self.user = User.objects.create_user( username="testuser", email="test@test.com", password="testpass123", role="loan_officer", branch=self.branch, phone_number="+254700000001" ) self.pdf_service = EnhancedPDFService() self.export_service = ExportService() def test_pdf_generation_with_branding(self): """Test PDF generation with company branding""" # Mock report data report_data = { 'title': 'Portfolio Performance Report', 'date_range': '2024-01-01 to 2024-01-31', 'manager': self.user.get_full_name(), 'metrics': { 'total_clients': 50, 'active_loans': 45, 'collection_rate': 85.5 }, 'charts': [] } # Generate PDF pdf_result = self.pdf_service.generate_portfolio_report(report_data) # Verify PDF generation self.assertIn('success', pdf_result) self.assertTrue(pdf_result['success']) self.assertIn('file_path', pdf_result) self.assertIn('file_size', pdf_result) def test_excel_export_with_formatting(self): """Test Excel export with proper formatting""" # Mock export data export_data = [ { 'client_name': 'John Doe', 'loan_amount': Decimal('10000.00'), 'status': 'Active', 'due_date': timezone.now().date() }, { 'client_name': 'Jane Smith', 'loan_amount': Decimal('15000.00'), 'status': 'Completed', 'due_date': timezone.now().date() - timedelta(days=30) } ] # Export to Excel excel_result = self.export_service.export_to_excel( data=export_data, filename='test_export', sheet_name='Loan Data', formatting_rules={ 'loan_amount': 'currency', 'due_date': 'date' } ) # Verify Excel export self.assertIn('success', excel_result) self.assertTrue(excel_result['success']) self.assertIn('file_path', excel_result) self.assertIn('rows_exported', excel_result) self.assertEqual(excel_result['rows_exported'], 2) def test_csv_export_functionality(self): """Test CSV export functionality""" # Mock export data export_data = [ {'name': 'Client 1', 'amount': 1000, 'status': 'Active'}, {'name': 'Client 2', 'amount': 2000, 'status': 'Pending'} ] # Export to CSV csv_result = self.export_service.export_to_csv( data=export_data, filename='test_export.csv' ) # Verify CSV export self.assertIn('success', csv_result) self.assertTrue(csv_result['success']) self.assertIn('file_path', csv_result) self.assertIn('rows_exported', csv_result) def test_batch_export_processing(self): """Test batch export processing""" batch_service = BatchProcessingService() # Mock batch export request export_requests = [ { 'type': 'pdf', 'template': 'portfolio_report', 'data': {'manager_id': self.user.id} }, { 'type': 'excel', 'template': 'client_list', 'data': {'branch_id': self.branch.id} } ] # Process batch exports with patch.object(batch_service, '_process_single_export') as mock_process: mock_process.return_value = {'success': True, 'file_path': '/tmp/test.pdf'} batch_result = batch_service.process_batch_exports(export_requests) # Verify batch processing self.assertIn('success', batch_result) self.assertTrue(batch_result['success']) self.assertIn('completed', batch_result) self.assertIn('failed', batch_result) self.assertEqual(batch_result['completed'], 2) def test_report_scheduling(self): """Test report scheduling functionality""" batch_service = BatchProcessingService() # Mock scheduled report schedule_config = { 'report_type': 'portfolio_summary', 'frequency': 'weekly', 'recipients': ['manager@test.com'], 'parameters': { 'branch_id': self.branch.id, 'include_charts': True } } # Schedule report schedule_result = batch_service.schedule_report(schedule_config) # Verify scheduling self.assertIn('success', schedule_result) self.assertTrue(schedule_result['success']) self.assertIn('schedule_id', schedule_result) self.assertIn('next_run', schedule_result) class AdvancedFilteringTest(TestCase): """Test cases for advanced filtering and sorting""" def setUp(self): """Set up test data""" self.filtering_service = AdvancedFilteringService() # Mock data for filtering self.test_data = [ { 'id': 1, 'name': 'John Doe', 'amount': Decimal('10000.00'), 'status': 'Active', 'date': timezone.now().date(), 'branch': 'Main' }, { 'id': 2, 'name': 'Jane Smith', 'amount': Decimal('15000.00'), 'status': 'Pending', 'date': timezone.now().date() - timedelta(days=10), 'branch': 'Branch A' }, { 'id': 3, 'name': 'Bob Johnson', 'amount': Decimal('5000.00'), 'status': 'Active', 'date': timezone.now().date() - timedelta(days=5), 'branch': 'Main' } ] def test_basic_filtering(self): """Test basic filtering functionality""" # Filter by status filters = {'status': 'Active'} filtered_data = self.filtering_service.apply_filters(self.test_data, filters) # Verify filtering self.assertEqual(len(filtered_data), 2) for item in filtered_data: self.assertEqual(item['status'], 'Active') def test_range_filtering(self): """Test range filtering for amounts and dates""" # Filter by amount range filters = { 'amount_min': Decimal('8000.00'), 'amount_max': Decimal('12000.00') } filtered_data = self.filtering_service.apply_filters(self.test_data, filters) # Verify range filtering self.assertEqual(len(filtered_data), 1) self.assertEqual(filtered_data[0]['name'], 'John Doe') def test_date_range_filtering(self): """Test date range filtering""" # Filter by date range (last 7 days) end_date = timezone.now().date() start_date = end_date - timedelta(days=7) filters = { 'date_start': start_date, 'date_end': end_date } filtered_data = self.filtering_service.apply_filters(self.test_data, filters) # Verify date filtering for item in filtered_data: self.assertGreaterEqual(item['date'], start_date) self.assertLessEqual(item['date'], end_date) def test_multiple_filters(self): """Test applying multiple filters simultaneously""" filters = { 'status': 'Active', 'branch': 'Main', 'amount_min': Decimal('8000.00') } filtered_data = self.filtering_service.apply_filters(self.test_data, filters) # Verify multiple filters self.assertEqual(len(filtered_data), 1) item = filtered_data[0] self.assertEqual(item['status'], 'Active') self.assertEqual(item['branch'], 'Main') self.assertGreaterEqual(item['amount'], Decimal('8000.00')) def test_sorting_functionality(self): """Test sorting functionality""" # Sort by amount descending sort_rules = [{'field': 'amount', 'direction': 'desc'}] sorted_data = self.filtering_service.apply_sorting(self.test_data, sort_rules) # Verify sorting self.assertEqual(sorted_data[0]['amount'], Decimal('15000.00')) self.assertEqual(sorted_data[1]['amount'], Decimal('10000.00')) self.assertEqual(sorted_data[2]['amount'], Decimal('5000.00')) def test_multi_column_sorting(self): """Test multi-column sorting""" # Sort by branch, then by amount sort_rules = [ {'field': 'branch', 'direction': 'asc'}, {'field': 'amount', 'direction': 'desc'} ] sorted_data = self.filtering_service.apply_sorting(self.test_data, sort_rules) # Verify multi-column sorting # Branch A items first, then Main branch items self.assertEqual(sorted_data[0]['branch'], 'Branch A') self.assertEqual(sorted_data[1]['branch'], 'Main') self.assertEqual(sorted_data[2]['branch'], 'Main') # Within Main branch, higher amount first main_items = [item for item in sorted_data if item['branch'] == 'Main'] self.assertGreater(main_items[0]['amount'], main_items[1]['amount']) def test_search_functionality(self): """Test search functionality""" # Search by name search_term = 'John' search_fields = ['name'] search_results = self.filtering_service.apply_search( self.test_data, search_term, search_fields ) # Verify search results self.assertEqual(len(search_results), 2) # John Doe and Bob Johnson for item in search_results: self.assertIn('John', item['name']) def test_filter_persistence(self): """Test filter persistence functionality""" # Save filter preset filter_preset = { 'name': 'Active High Value', 'filters': { 'status': 'Active', 'amount_min': Decimal('8000.00') }, 'sort': [{'field': 'amount', 'direction': 'desc'}] } # Save preset preset_id = self.filtering_service.save_filter_preset(filter_preset) self.assertIsNotNone(preset_id) # Load preset loaded_preset = self.filtering_service.load_filter_preset(preset_id) self.assertEqual(loaded_preset['name'], 'Active High Value') self.assertEqual(loaded_preset['filters']['status'], 'Active') class DataIntegrityTest(TestCase): """Test cases for data integrity validation""" def setUp(self): """Set up test data""" self.branch = Branch.objects.create( name="Test Branch", code="TB001", is_active=True ) self.user = User.objects.create_user( username="testuser", email="test@test.com", password="testpass123", role="loan_officer", branch=self.branch, phone_number="+254700000001" ) def test_portfolio_snapshot_data_integrity(self): """Test portfolio snapshot data integrity""" # Create snapshot with valid data snapshot = PortfolioSnapshot.objects.create( manager=self.user, branch=self.branch, snapshot_date=timezone.now().date(), total_clients=10, active_clients=9, active_loans=8, total_disbursed=Decimal('100000.00'), total_outstanding=Decimal('60000.00'), total_collected=Decimal('40000.00') ) # Validate data integrity self.assertLessEqual(snapshot.active_clients, snapshot.total_clients) self.assertLessEqual(snapshot.active_loans, snapshot.active_clients) self.assertEqual( snapshot.total_disbursed, snapshot.total_outstanding + snapshot.total_collected ) def test_client_growth_metrics_integrity(self): """Test client growth metrics data integrity""" # Create growth metrics metrics = ClientGrowthMetrics.objects.create( branch=self.branch, period_start=timezone.now().date().replace(day=1), period_end=timezone.now().date(), new_clients=10, churned_clients=2, reactivated_clients=1, total_clients=50, acquisition_cost=Decimal('500.00'), lifetime_value=Decimal('2000.00') ) # Validate data integrity self.assertGreaterEqual(metrics.new_clients, 0) self.assertGreaterEqual(metrics.churned_clients, 0) self.assertGreaterEqual(metrics.total_clients, 0) self.assertGreater(metrics.lifetime_value, metrics.acquisition_cost) def test_calculation_accuracy(self): """Test accuracy of calculations""" # Test percentage calculations total = 100 part = 25 percentage = (part / total) * 100 self.assertEqual(percentage, 25.0) # Test growth rate calculations old_value = Decimal('80.00') new_value = Decimal('100.00') growth_rate = ((new_value - old_value) / old_value) * 100 self.assertEqual(growth_rate, Decimal('25.00')) def test_decimal_precision(self): """Test decimal precision in calculations""" # Test monetary calculations amount1 = Decimal('10000.50') amount2 = Decimal('5000.25') total = amount1 + amount2 self.assertEqual(total, Decimal('15000.75')) # Test percentage calculations with decimals rate = Decimal('12.5') amount = Decimal('1000.00') result = (amount * rate) / 100 self.assertEqual(result, Decimal('125.00')) def test_date_range_validation(self): """Test date range validation""" start_date = timezone.now().date() end_date = start_date + timedelta(days=30) # Valid date range self.assertLess(start_date, end_date) # Invalid date range should be caught invalid_end = start_date - timedelta(days=1) self.assertGreater(start_date, invalid_end) def test_export_data_integrity(self): """Test data integrity in exports""" # Mock export data original_data = [ {'id': 1, 'amount': Decimal('1000.50'), 'date': timezone.now().date()}, {'id': 2, 'amount': Decimal('2000.75'), 'date': timezone.now().date()} ] # Simulate export process export_service = ExportService() # Mock the export process with patch.object(export_service, 'export_to_excel') as mock_export: mock_export.return_value = { 'success': True, 'rows_exported': len(original_data), 'data_checksum': 'abc123' } result = export_service.export_to_excel(original_data, 'test.xlsx') # Verify data integrity self.assertTrue(result['success']) self.assertEqual(result['rows_exported'], 2) self.assertIn('data_checksum', result)