Delete tests

tests/README.md

@@ -1,130 +0,0 @@
-# اختبارات نظام تسعير المناقصات
-
-يحتوي هذا المجلد على اختبارات وحدة واختبارات تكامل لنظام تسعير المناقصات.
-
-## هيكل المجلد
-
-- `unit/`: اختبارات الوحدة للمكونات الفردية
-- `integration/`: اختبارات التكامل بين مكونات النظام المختلفة
-
-## تشغيل الاختبارات
-
-### تشغيل جميع الاختبارات
-
-لتشغيل جميع الاختبارات، قم بتنفيذ الأمر التالي من المجلد الرئيسي للمشروع:
-
-```bash
-python -m unittest discover -s tests
-```
-
-### تشغيل اختبارات الوحدة فقط
-
-```bash
-python -m unittest discover -s tests/unit
-```
-
-### تشغيل اختبارات التكامل فقط
-
-```bash
-python -m unittest discover -s tests/integration
-```
-
-### تشغيل ملف اختبار محدد
-
-```bash
-python -m unittest tests/unit/test_reports.py
-```
-
-## كتابة اختبارات جديدة
-
-### اختبارات الوحدة
-
-اختبارات الوحدة تركز على اختبار مكون واحد معزول عن باقي النظام. يجب اتباع النمط التالي:
-
-```python
-import unittest
-
-class TestComponentName(unittest.TestCase):
-    
-    def setUp(self):
-        # إعداد بيئة الاختبار
-        pass
-    
-    def tearDown(self):
-        # تنظيف بيئة الاختبار
-        pass
-    
-    def test_functionality_name(self):
-        # اختبار وظيفة معينة
-        result = function_to_test(params)
-        self.assertEqual(result, expected_value)
-```
-
-### اختبارات التكامل
-
-اختبارات التكامل تركز على التفاعل بين مكونين أو أكثر. يجب اتباع النمط التالي:
-
-```python
-import unittest
-
-class TestIntegrationName(unittest.TestCase):
-    
-    def setUp(self):
-        # إعداد بيئة الاختبار
-        # إنشاء المكونات المختلفة المطلوبة
-        pass
-    
-    def tearDown(self):
-        # تنظيف بيئة الاختبار
-        pass
-    
-    def test_integration_scenario(self):
-        # اختبار سيناريو تكامل محدد
-        result = component1.action(params)
-        component2.process(result)
-        final_result = component2.get_result()
-        self.assertEqual(final_result, expected_value)
-```
-
-## المحاكاة والاستبدال
-
-في بعض الحالات، قد نحتاج إلى محاكاة بعض المكونات لعزل المكون الذي نختبره. يمكن استخدام مكتبة `unittest.mock` لهذا الغرض:
-
-```python
-from unittest.mock import Mock, patch
-
-class TestWithMocking(unittest.TestCase):
-    
-    @patch('module.ClassName')
-    def test_with_mock(self, MockClass):
-        # إعداد المحاكاة
-        instance = MockClass.return_value
-        instance.method.return_value = 'mocked_result'
-        
-        # استدعاء الدالة التي تستخدم الكائن المحاكى
-        result = function_to_test()
-        
-        # التحقق من النتائج ومن استدعاء المحاكاة
-        self.assertEqual(result, expected_value)
-        instance.method.assert_called_once_with(expected_params)
-```
-
-## التغطية
-
-يمكن قياس تغطية الاختبارات باستخدام أداة `coverage`:
-
-```bash
-# تثبيت أداة coverage
-pip install coverage
-
-# تشغيل الاختبارات مع قياس التغطية
-coverage run -m unittest discover -s tests
-
-# عرض تقرير التغطية
-coverage report
-
-# إنشاء تقرير HTML للتغطية
-coverage html
-```
-
-ملف تقرير HTML سيكون في مجلد `htmlcov/index.html`.

tests/integration/test_dashboard.py

@@ -1,266 +0,0 @@
-"""
-اختبارات تكامل للوحة المعلومات
-"""
-
-import unittest
-import pandas as pd
-import numpy as np
-import os
-import sys
-import json
-from datetime import datetime, timedelta
-
-# إضافة المسار الرئيسي للمشروع لاستيراد الوحدات
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
-
-from modules.reports.reports_app import ReportsApp
-import streamlit as st
-
-
-class TestDashboard(unittest.TestCase):
-    """اختبارات تكامل للوحة المعلومات"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.reports_app = ReportsApp()
-        
-        # إنشاء بيانات محاكاة للمشاريع
-        self.mock_projects = [
-            {
-                'id': 1,
-                'name': 'مشروع 1',
-                'number': 'T-2024001',
-                'client': 'وزارة الصحة',
-                'location': 'الرياض',
-                'status': 'جديد',
-                'submission_date': '2024-01-15',
-                'tender_type': 'عامة',
-                'created_at': '2024-01-10',
-                'value': 1500000,
-                'local_content': 75
-            },
-            {
-                'id': 2,
-                'name': 'مشروع 2',
-                'number': 'T-2024002',
-                'client': 'وزارة التعليم',
-                'location': 'جدة',
-                'status': 'قيد التسعير',
-                'submission_date': '2024-01-28',
-                'tender_type': 'خاصة',
-                'created_at': '2024-01-20',
-                'value': 4500000,
-                'local_content': 80
-            },
-            {
-                'id': 3,
-                'name': 'مشروع 3',
-                'number': 'T-2024003',
-                'client': 'وزارة الصحة',
-                'location': 'الدمام',
-                'status': 'تم التقديم',
-                'submission_date': '2024-02-10',
-                'tender_type': 'عامة',
-                'created_at': '2024-02-01',
-                'value': 8000000,
-                'local_content': 70
-            },
-            {
-                'id': 4,
-                'name': 'مشروع 4',
-                'number': 'T-2024004',
-                'client': 'شركة أرامكو',
-                'location': 'الظهران',
-                'status': 'تمت الترسية',
-                'submission_date': '2024-02-15',
-                'tender_type': 'عامة',
-                'created_at': '2024-02-05',
-                'value': 15000000,
-                'local_content': 85
-            },
-            {
-                'id': 5,
-                'name': 'مشروع 5',
-                'number': 'T-2024005',
-                'client': 'شركة سابك',
-                'location': 'الجبيل',
-                'status': 'قيد التنفيذ',
-                'submission_date': '2024-02-20',
-                'tender_type': 'خاصة',
-                'created_at': '2024-02-10',
-                'value': 25000000,
-                'local_content': 75
-            },
-            {
-                'id': 6,
-                'name': 'مشروع 6',
-                'number': 'T-2024006',
-                'client': 'وزارة النقل',
-                'location': 'الرياض',
-                'status': 'منتهي',
-                'submission_date': '2024-01-05',
-                'tender_type': 'عامة',
-                'created_at': '2023-12-20',
-                'value': 5000000,
-                'local_content': 72
-            },
-            {
-                'id': 7,
-                'name': 'مشروع 7',
-                'number': 'T-2024007',
-                'client': 'وزارة الإسكان',
-                'location': 'مكة',
-                'status': 'ملغي',
-                'submission_date': '2024-01-10',
-                'tender_type': 'خاصة',
-                'created_at': '2023-12-25',
-                'value': 12000000,
-                'local_content': 65
-            }
-        ]
-        
-        # تعيين المشاريع في حالة الجلسة
-        st.session_state.projects = self.mock_projects
-    
-    def test_dashboard_metrics(self):
-        """اختبار مؤشرات لوحة المعلومات الرئيسية"""
-        # الحصول على المؤشرات
-        total_projects = self.reports_app._get_total_projects()
-        active_projects = self.reports_app._get_active_projects()
-        won_projects = self.reports_app._get_won_projects()
-        avg_local_content = self.reports_app._get_avg_local_content()
-        
-        # التحقق من المؤشرات
-        self.assertEqual(total_projects, 7)
-        self.assertEqual(active_projects, 4)  # قيد التسعير، تم التقديم، تمت الترسية، قيد التنفيذ
-        self.assertEqual(won_projects, 3)  # تمت الترسية، قيد التنفيذ، منتهي
-        
-        # التحقق من أن متوسط المحتوى المحلي قريب من القيمة المتوقعة
-        expected_avg_local_content = sum(p['local_content'] for p in self.mock_projects) / len(self.mock_projects)
-        self.assertAlmostEqual(avg_local_content, expected_avg_local_content, delta=1.0)
-    
-    def test_project_status_distribution(self):
-        """اختبار توزيع المشاريع حسب الحالة"""
-        # الحصول على بيانات التوزيع
-        status_data = self.reports_app._get_project_status_data()
-        
-        # التحقق من أن البيانات إطار بيانات
-        self.assertIsInstance(status_data, pd.DataFrame)
-        
-        # التحقق من الأعمدة
-        self.assertIn('status', status_data.columns)
-        self.assertIn('count', status_data.columns)
-        
-        # التحقق من أن عدد الحالات الفريدة يساوي 7
-        self.assertEqual(len(status_data), 7)
-        
-        # التحقق من أن مجموع المشاريع صحيح
-        self.assertEqual(status_data['count'].sum(), 7)
-        
-        # التحقق من عدد المشاريع في كل حالة
-        status_counts = status_data.set_index('status')['count'].to_dict()
-        self.assertEqual(status_counts['جديد'], 1)
-        self.assertEqual(status_counts['قيد التسعير'], 1)
-        self.assertEqual(status_counts['تم التقديم'], 1)
-        self.assertEqual(status_counts['تمت الترسية'], 1)
-        self.assertEqual(status_counts['قيد التنفيذ'], 1)
-        self.assertEqual(status_counts['منتهي'], 1)
-        self.assertEqual(status_counts['ملغي'], 1)
-    
-    def test_monthly_trend_data(self):
-        """اختبار بيانات الاتجاه الشهري"""
-        # الحصول على بيانات الاتجاه
-        monthly_data = self.reports_app._get_monthly_project_data()
-        
-        # التحقق من أن البيانات إطار بيانات
-        self.assertIsInstance(monthly_data, pd.DataFrame)
-        
-        # التحقق من الأعمدة
-        self.assertIn('month', monthly_data.columns)
-        self.assertIn('new', monthly_data.columns)
-        self.assertIn('submitted', monthly_data.columns)
-        self.assertIn('won', monthly_data.columns)
-        
-        # التحقق من أن عدد الأشهر يساوي 6
-        self.assertEqual(len(monthly_data), 6)
-    
-    def test_project_value_distribution(self):
-        """اختبار توزيع المشاريع حسب القيمة"""
-        # الحصول على بيانات التوزيع
-        value_data = self.reports_app._get_project_value_data()
-        
-        # التحقق من أن البيانات إطار بيانات
-        self.assertIsInstance(value_data, pd.DataFrame)
-        
-        # التحقق من الأعمدة
-        self.assertIn('range', value_data.columns)
-        self.assertIn('count', value_data.columns)
-        
-        # التحقق من أن عدد النطاقات يساوي 7
-        self.assertEqual(len(value_data), 7)
-        
-        # التحقق من أن عدد المشاريع صحيح
-        self.assertEqual(value_data['count'].sum(), 7)
-        
-        # التحقق من نطاقات القيمة
-        value_ranges = value_data['range'].tolist()
-        self.assertIn('أقل من 1 مليون', value_ranges)
-        self.assertIn('1-5 مليون', value_ranges)
-        self.assertIn('5-10 مليون', value_ranges)
-        self.assertIn('10-20 مليون', value_ranges)
-        self.assertIn('20-50 مليون', value_ranges)
-    
-    def test_custom_report_generation(self):
-        """اختبار إنشاء التقارير المخصصة"""
-        # اختبار إنشاء تقرير جدول
-        table_data = self.reports_app._generate_sample_data(
-            data_source="المشاريع",
-            fields=["اسم المشروع", "العميل", "الحالة", "تاريخ التقديم"],
-            rows=10
-        )
-        
-        # التحقق من النتائج
-        self.assertIsInstance(table_data, pd.DataFrame)
-        self.assertEqual(len(table_data), 10)
-        self.assertEqual(len(table_data.columns), 4)
-        
-        # اختبار فلترة البيانات
-        filters = [
-            {
-                'field': 'العميل',
-                'operator': 'يساوي',
-                'value': 'وزارة الصحة'
-            }
-        ]
-        
-        filtered_data = table_data.copy()
-        for filter_info in filters:
-            field = filter_info['field']
-            operator = filter_info['operator']
-            value = filter_info['value']
-            
-            if field in filtered_data.columns:
-                if operator == "يساوي":
-                    filtered_data = filtered_data[filtered_data[field] == value]
-        
-        # التحقق من أن الفلترة تعمل بشكل صحيح
-        if not filtered_data.empty:
-            self.assertTrue(all(client == 'وزارة الصحة' for client in filtered_data['العميل']))
-    
-    def test_report_export_functionality(self):
-        """اختبار وظيفة تصدير التقارير"""
-        # في هذا الاختبار نفترض وجود وظيفة تصدير تعمل بشكل صحيح
-        # ونتحقق فقط من أن البيانات جاهزة للتصدير
-        
-        # الحصول على بيانات المشاريع
-        project_data = pd.DataFrame(self.mock_projects)
-        
-        # التحقق من أن البيانات جاهزة للتصدير
-        self.assertTrue(len(project_data) > 0)
-        self.assertIn('name', project_data.columns)
-        self.assertIn('client', project_data.columns)
-        self.assertIn('status', project_data.columns)
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/integration/test_report_export.py

@@ -1,246 +0,0 @@
-"""
-اختبارات تكامل لتصدير التقارير
-"""
-
-import unittest
-import pandas as pd
-import os
-import sys
-import tempfile
-import shutil
-from datetime import datetime
-
-# إضافة المسار الرئيسي للمشروع لاستيراد الوحدات
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
-
-from modules.reports.reports_app import ReportsApp
-from utils.excel_handler import export_to_excel
-
-
-class TestReportExport(unittest.TestCase):
-    """اختبارات تكامل لتصدير التقارير"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.reports_app = ReportsApp()
-        
-        # إنشاء مجلد مؤقت للملفات المصدرة
-        self.test_dir = tempfile.mkdtemp()
-        
-        # إنشاء بيانات محاكاة للمشاريع
-        self.projects_data = pd.DataFrame({
-            'اسم المشروع': [f'مشروع {i}' for i in range(1, 6)],
-            'رقم المناقصة': [f'T-2024{i:03d}' for i in range(1, 6)],
-            'العميل': ['وزارة الصحة', 'وزارة التعليم', 'وزارة الصحة', 'شركة أرامكو', 'شركة سابك'],
-            'الموقع': ['الرياض', 'جدة', 'الدمام', 'الظهران', 'الجبيل'],
-            'الحالة': ['جديد', 'قيد التسعير', 'تم التقديم', 'تمت الترسية', 'قيد التنفيذ'],
-            'تاريخ التقديم': ['2024-01-15', '2024-01-28', '2024-02-10', '2024-02-15', '2024-02-20'],
-            'نوع المناقصة': ['عامة', 'خاصة', 'عامة', 'عامة', 'خاصة']
-        })
-        
-        # إنشاء بيانات محاكاة للتسعير
-        self.pricing_data = pd.DataFrame({
-            'اسم المشروع': ['مشروع 1', 'مشروع 1', 'مشروع 1', 'مشروع 2', 'مشروع 2'],
-            'رقم البند': ['A001', 'A002', 'A003', 'B001', 'B002'],
-            'وصف البند': [
-                'أعمال الحفر والردم',
-                'أعمال الخرسانة المسلحة',
-                'أعمال حديد التسليح',
-                'أعمال البلوك',
-                'أعمال اللياسة'
-            ],
-            'الوحدة': ['م3', 'م3', 'طن', 'م2', 'م2'],
-            'الكمية': [1000, 500, 50, 800, 1200],
-            'سعر الوحدة': [50, 1200, 5000, 120, 80],
-            'الإجمالي': [50000, 600000, 250000, 96000, 96000]
-        })
-        
-        # إنشاء بيانات محاكاة للمخاطر
-        self.risks_data = pd.DataFrame({
-            'رمز المخاطرة': [f'R{i:03d}' for i in range(1, 6)],
-            'اسم المشروع': ['مشروع 1', 'مشروع 1', 'مشروع 2', 'مشروع 3', 'مشروع 4'],
-            'وصف المخاطرة': [
-                'غرامة تأخير مرتفعة',
-                'مدة تنفيذ قصيرة',
-                'متطلبات ضمان بنكي مرتفعة',
-                'شروط دفع متأخرة',
-                'متطلبات تأمين شاملة ومكلفة'
-            ],
-            'الفئة': [
-                'مخاطر مالية',
-                'مخاطر زمنية',
-                'مخاطر مالية',
-                'مخاطر مالية',
-                'مخاطر مالية'
-            ],
-            'التأثير': ['عالي', 'متوسط', 'منخفض', 'عالي', 'متوسط'],
-            'الاحتمالية': ['محتمل', 'مؤكد', 'غير محتمل', 'محتمل', 'غير محتمل'],
-            'درجة المخاطرة': [6, 6, 2, 8, 4]
-        })
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        # حذف المجلد المؤقت
-        shutil.rmtree(self.test_dir)
-    
-    def test_export_projects_report_to_excel(self):
-        """اختبار تصدير تقرير المشاريع إلى Excel"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'projects_report.xlsx')
-        
-        # تصدير البيانات
-        result = export_to_excel(self.projects_data, output_file, sheet_name='المشاريع', title='تقرير المشاريع')
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result)
-        self.assertTrue(os.path.exists(output_file))
-        
-        # التحقق من محتوى الملف المصدر
-        imported_data = pd.read_excel(output_file, sheet_name='المشاريع', skiprows=2)  # تخطي الصفوف الأولى (العنوان)
-        
-        # التحقق من عدد الصفوف والأعمدة
-        self.assertEqual(len(imported_data), len(self.projects_data))
-        self.assertEqual(len(imported_data.columns), len(self.projects_data.columns))
-    
-    def test_export_pricing_report_to_excel(self):
-        """اختبار تصدير تقرير التسعير إلى Excel"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'pricing_report.xlsx')
-        
-        # تصدير البيانات
-        result = export_to_excel(self.pricing_data, output_file, sheet_name='التسعير', title='تقرير التسعير')
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result)
-        self.assertTrue(os.path.exists(output_file))
-        
-        # التحقق من محتوى الملف المصدر
-        imported_data = pd.read_excel(output_file, sheet_name='التسعير', skiprows=2)  # تخطي الصفوف الأولى (العنوان)
-        
-        # التحقق من عدد الصفوف والأعمدة
-        self.assertEqual(len(imported_data), len(self.pricing_data))
-        self.assertEqual(len(imported_data.columns), len(self.pricing_data.columns))
-    
-    def test_export_multiple_sheets(self):
-        """اختبار تصدير تقرير متعدد الصفحات"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'combined_report.xlsx')
-        
-        # تصدير البيانات متعددة الصفحات
-        result1 = export_to_excel(self.projects_data, output_file, sheet_name='المشاريع', title='تقرير المشاريع')
-        result2 = export_to_excel(self.pricing_data, output_file, sheet_name='التسعير', title='تقرير التسعير', append=True)
-        result3 = export_to_excel(self.risks_data, output_file, sheet_name='المخاطر', title='تقرير المخاطر', append=True)
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result1)
-        self.assertTrue(result2)
-        self.assertTrue(result3)
-        self.assertTrue(os.path.exists(output_file))
-        
-        # التحقق من وجود جميع الصفحات
-        excel_file = pd.ExcelFile(output_file)
-        self.assertIn('المشاريع', excel_file.sheet_names)
-        self.assertIn('التسعير', excel_file.sheet_names)
-        self.assertIn('المخاطر', excel_file.sheet_names)
-        
-        # التحقق من محتوى كل صفحة
-        projects_data = pd.read_excel(output_file, sheet_name='المشاريع', skiprows=2)
-        pricing_data = pd.read_excel(output_file, sheet_name='التسعير', skiprows=2)
-        risks_data = pd.read_excel(output_file, sheet_name='المخاطر', skiprows=2)
-        
-        self.assertEqual(len(projects_data), len(self.projects_data))
-        self.assertEqual(len(pricing_data), len(self.pricing_data))
-        self.assertEqual(len(risks_data), len(self.risks_data))
-    
-    def test_export_with_formatting(self):
-        """اختبار تصدير تقرير مع التنسيق"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'formatted_report.xlsx')
-        
-        # تصدير البيانات مع تنسيق
-        formatting = {
-            'header_format': {
-                'bold': True,
-                'bg_color': '#4F81BD',
-                'font_color': 'white',
-                'border': 1,
-                'align': 'center'
-            },
-            'row_formats': [
-                {
-                    'columns': ['الإجمالي'],
-                    'num_format': '#,##0.00 ريال'
-                },
-                {
-                    'columns': ['الكمية'],
-                    'num_format': '#,##0.00'
-                }
-            ],
-            'conditional_formats': [
-                {
-                    'column': 'درجة المخاطرة',
-                    'criteria': '>',
-                    'value': 6,
-                    'format': {'bg_color': '#FF9999'}
-                }
-            ]
-        }
-        
-        result = export_to_excel(self.risks_data, output_file, sheet_name='المخاطر', 
-                                 title='تقرير المخاطر', formatting=formatting)
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result)
-        self.assertTrue(os.path.exists(output_file))
-    
-    def test_export_with_filters(self):
-        """اختبار تصدير تقرير مع تصفية"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'filtered_report.xlsx')
-        
-        # تصدير البيانات المشاريع المفلترة (فقط مشاريع وزارة الصحة)
-        filtered_data = self.projects_data[self.projects_data['العميل'] == 'وزارة الصحة']
-        result = export_to_excel(filtered_data, output_file, sheet_name='مشاريع الصحة', 
-                                 title='تقرير مشاريع وزارة الصحة')
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result)
-        self.assertTrue(os.path.exists(output_file))
-        
-        # التحقق من محتوى الملف المصدر
-        imported_data = pd.read_excel(output_file, sheet_name='مشاريع الصحة', skiprows=2)
-        
-        # التحقق من أن جميع المشاريع تنتمي لوزارة الصحة
-        self.assertEqual(len(imported_data), 2)
-        self.assertTrue(all(client == 'وزارة الصحة' for client in imported_data['العميل']))
-    
-    def test_export_with_summary(self):
-        """اختبار تصدير تقرير مع ملخص"""
-        # إنشاء مسار الملف المصدر
-        output_file = os.path.join(self.test_dir, 'summary_report.xlsx')
-        
-        # إنشاء بيانات الملخص
-        summary_data = pd.DataFrame({
-            'المؤشر': ['إجمالي المشاريع', 'المشاريع النشطة', 'المشاريع المرساة', 'نسبة النجاح'],
-            'القيمة': [5, 4, 2, '40%']
-        })
-        
-        # تصدير البيانات مع ملخص
-        result1 = export_to_excel(summary_data, output_file, sheet_name='الملخص', 
-                                  title='ملخص تقرير المشاريع')
-        result2 = export_to_excel(self.projects_data, output_file, sheet_name='البيانات', 
-                                  title='تفاصيل المشاريع', append=True)
-        
-        # التحقق من نجاح التصدير
-        self.assertTrue(result1)
-        self.assertTrue(result2)
-        self.assertTrue(os.path.exists(output_file))
-        
-        # التحقق من وجود صفحات الملخص والبيانات
-        excel_file = pd.ExcelFile(output_file)
-        self.assertIn('الملخص', excel_file.sheet_names)
-        self.assertIn('البيانات', excel_file.sheet_names)
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_app.py

@@ -1,601 +0,0 @@
-"""
-وحدة اختبار التطبيق لنظام إدارة المناقصات - Hybrid Face
-"""
-
-import os
-import sys
-import logging
-import unittest
-import tkinter as tk
-from pathlib import Path
-
-# تهيئة السجل
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger('test_app')
-
-# إضافة المسار الرئيسي للتطبيق إلى مسار البحث
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# استيراد الوحدات المطلوبة للاختبار
-from database.db_connector import DatabaseConnector
-from database.models import User, Project, Document, ProjectItem, Resource, Risk, Report, SystemLog
-from modules.document_analysis.analyzer import DocumentAnalyzer
-from modules.pricing.pricing_engine import PricingEngine
-from modules.risk_analysis.risk_analyzer import RiskAnalyzer
-from modules.ai_assistant.assistant import AIAssistant
-from styling.theme import AppTheme
-from styling.icons import IconGenerator
-from styling.charts import ChartGenerator
-from config import AppConfig
-
-class TestDatabaseConnector(unittest.TestCase):
-    """اختبار وحدة اتصال قاعدة البيانات"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        # استخدام قاعدة بيانات اختبار مؤقتة
-        self.config = AppConfig()
-        self.config.DB_NAME = "test_tender_system.db"
-        self.db = DatabaseConnector(self.config)
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        self.db.disconnect()
-        # حذف قاعدة البيانات المؤقتة
-        if os.path.exists(self.config.DB_NAME):
-            os.remove(self.config.DB_NAME)
-    
-    def test_connection(self):
-        """اختبار الاتصال بقاعدة البيانات"""
-        self.assertTrue(self.db.is_connected)
-    
-    def test_execute_query(self):
-        """اختبار تنفيذ استعلام"""
-        cursor = self.db.execute("SELECT 1")
-        self.assertIsNotNone(cursor)
-        result = cursor.fetchone()
-        self.assertEqual(result[0], 1)
-    
-    def test_insert_and_fetch(self):
-        """اختبار إدراج واسترجاع البيانات"""
-        # إدراج بيانات
-        user_data = {
-            "username": "test_user",
-            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
-            "full_name": "مستخدم اختبار",
-            "email": "[email protected]",
-            "role": "user"
-        }
-        user_id = self.db.insert("users", user_data)
-        self.assertIsNotNone(user_id)
-        
-        # استرجاع البيانات
-        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
-        self.assertIsNotNone(user)
-        self.assertEqual(user["username"], "test_user")
-        self.assertEqual(user["full_name"], "مستخدم اختبار")
-    
-    def test_update(self):
-        """اختبار تحديث البيانات"""
-        # إدراج بيانات
-        user_data = {
-            "username": "update_user",
-            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
-            "full_name": "مستخدم للتحديث",
-            "email": "[email protected]",
-            "role": "user"
-        }
-        user_id = self.db.insert("users", user_data)
-        
-        # تحديث البيانات
-        updated_data = {
-            "full_name": "مستخدم تم تحديثه",
-            "role": "admin"
-        }
-        rows_affected = self.db.update("users", updated_data, "id = ?", (user_id,))
-        self.assertEqual(rows_affected, 1)
-        
-        # التحقق من التحديث
-        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
-        self.assertEqual(user["full_name"], "مستخدم تم تحديثه")
-        self.assertEqual(user["role"], "admin")
-    
-    def test_delete(self):
-        """اختبار حذف البيانات"""
-        # إدراج بيانات
-        user_data = {
-            "username": "delete_user",
-            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
-            "full_name": "مستخدم للحذف",
-            "email": "[email protected]",
-            "role": "user"
-        }
-        user_id = self.db.insert("users", user_data)
-        
-        # حذف البيانات
-        rows_affected = self.db.delete("users", "id = ?", (user_id,))
-        self.assertEqual(rows_affected, 1)
-        
-        # التحقق من الحذف
-        user = self.db.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
-        self.assertIsNone(user)
-
-
-class TestModels(unittest.TestCase):
-    """اختبار نماذج البيانات"""
-    
-    def setUp(self):
-        """��عداد بيئة الاختبار"""
-        # استخدام قاعدة بيانات اختبار مؤقتة
-        self.config = AppConfig()
-        self.config.DB_NAME = "test_models.db"
-        self.db = DatabaseConnector(self.config)
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        self.db.disconnect()
-        # حذف قاعدة البيانات المؤقتة
-        if os.path.exists(self.config.DB_NAME):
-            os.remove(self.config.DB_NAME)
-    
-    def test_user_model(self):
-        """اختبار نموذج المستخدم"""
-        # إنشاء مستخدم جديد
-        user = User(self.db)
-        user.data = {
-            "username": "model_user",
-            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
-            "full_name": "مستخدم نموذج",
-            "email": "[email protected]",
-            "role": "user",
-            "is_active": 1
-        }
-        
-        # حفظ المستخدم
-        self.assertTrue(user.save())
-        self.assertIsNotNone(user.data.get("id"))
-        
-        # استرجاع المستخدم
-        retrieved_user = User.get_by_id(user.data["id"], self.db)
-        self.assertIsNotNone(retrieved_user)
-        self.assertEqual(retrieved_user.data["username"], "model_user")
-        
-        # مصادقة المستخدم
-        authenticated_user = User.authenticate("model_user", "admin", self.db)
-        self.assertIsNotNone(authenticated_user)
-        self.assertEqual(authenticated_user.data["username"], "model_user")
-        
-        # تعيين كلمة مرور جديدة
-        user.set_password("newpassword")
-        user.save()
-        
-        # مصادقة المستخدم بكلمة المرور الجديدة
-        authenticated_user = User.authenticate("model_user", "newpassword", self.db)
-        self.assertIsNotNone(authenticated_user)
-        
-        # حذف المستخدم
-        self.assertTrue(user.delete())
-    
-    def test_project_model(self):
-        """اختبار نموذج المشروع"""
-        # إنشاء مستخدم للمشروع
-        user = User(self.db)
-        user.data = {
-            "username": "project_user",
-            "password": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918",  # admin
-            "full_name": "مستخدم المشروع",
-            "email": "[email protected]",
-            "role": "user",
-            "is_active": 1
-        }
-        user.save()
-        
-        # إنشاء مشروع جديد
-        project = Project(self.db)
-        project.data = {
-            "name": "مشروع اختبار",
-            "client": "عميل اختبار",
-            "description": "وصف مشروع الاختبار",
-            "start_date": "2025-01-01",
-            "end_date": "2025-12-31",
-            "status": "تخطيط",
-            "created_by": user.data["id"]
-        }
-        
-        # حفظ المشروع
-        self.assertTrue(project.save())
-        self.assertIsNotNone(project.data.get("id"))
-        
-        # استرجاع المشروع
-        retrieved_project = Project.get_by_id(project.data["id"], self.db)
-        self.assertIsNotNone(retrieved_project)
-        self.assertEqual(retrieved_project.data["name"], "مشروع اختبار")
-        
-        # إضافة بند للمشروع
-        item = ProjectItem(self.db)
-        item.data = {
-            "project_id": project.data["id"],
-            "name": "بند اختبار",
-            "description": "وصف بند الاختبار",
-            "unit": "م²",
-            "quantity": 100,
-            "unit_price": 500,
-            "total_price": 50000
-        }
-        item.save()
-        
-        # حساب التكلفة الإجمالية للمشروع
-        total_cost = project.calculate_total_cost()
-        self.assertEqual(total_cost, 50000)
-        
-        # حذف المشروع
-        self.assertTrue(project.delete())
-        
-        # حذف المستخدم
-        self.assertTrue(user.delete())
-
-
-class TestDocumentAnalyzer(unittest.TestCase):
-    """اختبار محلل المستندات"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.config = AppConfig()
-        self.analyzer = DocumentAnalyzer(self.config)
-        
-        # إنشاء مجلد المستندات للاختبار
-        self.test_docs_dir = Path("test_documents")
-        self.test_docs_dir.mkdir(exist_ok=True)
-        
-        # إنشاء ملف مستند اختبار
-        self.test_doc_path = self.test_docs_dir / "test_document.txt"
-        with open(self.test_doc_path, "w", encoding="utf-8") as f:
-            f.write("هذا مستند اختبار لمحلل المستندات")
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        # حذف ملف المستند
-        if self.test_doc_path.exists():
-            self.test_doc_path.unlink()
-        
-        # حذف مجلد المستندات
-        if self.test_docs_dir.exists():
-            self.test_docs_dir.rmdir()
-    
-    def test_analyze_document(self):
-        """اختبار تحليل المستند"""
-        # تحليل المستند
-        result = self.analyzer.analyze_document(str(self.test_doc_path), "tender")
-        self.assertTrue(result)
-        
-        # انتظار اكتمال التحليل
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.analyzer.analysis_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # التحقق من نتائج التحليل
-        self.assertFalse(self.analyzer.analysis_in_progress)
-        results = self.analyzer.get_analysis_results()
-        self.assertEqual(results["status"], "اكتمل التحليل")
-        self.assertEqual(results["document_path"], str(self.test_doc_path))
-    
-    def test_export_analysis_results(self):
-        """اختبار تصدير نتائج التحليل"""
-        # تحليل المستند
-        self.analyzer.analyze_document(str(self.test_doc_path), "tender")
-        
-        # انتظار اكتمال التحليل
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.analyzer.analysis_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # تصدير النتائج
-        export_path = self.test_docs_dir / "analysis_results.json"
-        result_path = self.analyzer.export_analysis_results(str(export_path))
-        self.assertIsNotNone(result_path)
-        
-        # التحقق من وجود ملف التصدير
-        self.assertTrue(export_path.exists())
-        
-        # حذف ملف التصدير
-        if export_path.exists():
-            export_path.unlink()
-
-
-class TestPricingEngine(unittest.TestCase):
-    """اختبار محرك التسعير"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.config = AppConfig()
-        self.pricing_engine = PricingEngine(self.config)
-    
-    def test_calculate_pricing(self):
-        """اختبار حساب التسعير"""
-        # حساب التسعير
-        result = self.pricing_engine.calculate_pricing(1, "comprehensive")
-        self.assertTrue(result)
-        
-        # انتظار اكتمال التسعير
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.pricing_engine.pricing_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # التحقق من نتائج التسعير
-        self.assertFalse(self.pricing_engine.pricing_in_progress)
-        results = self.pricing_engine.get_pricing_results()
-        self.assertEqual(results["status"], "اكتمل التسعير")
-        self.assertEqual(results["project_id"], 1)
-        self.assertEqual(results["strategy"], "comprehensive")
-        
-        # التحقق من وجود التكاليف المباشرة
-        self.assertIn("direct_costs", results)
-        self.assertIn("total_direct_costs", results["direct_costs"])
-        
-        # التحقق من وجود التكاليف غير المباشرة
-        self.assertIn("indirect_costs", results)
-        self.assertIn("total_indirect_costs", results["indirect_costs"])
-        
-        # التحقق من وجود تكاليف المخاطر
-        self.assertIn("risk_costs", results)
-        self.assertIn("total_risk_cost", results["risk_costs"])
-        
-        # التحقق من وجود ملخص التسعير
-        self.assertIn("summary", results)
-        self.assertIn("final_price", results["summary"])
-
-
-class TestRiskAnalyzer(unittest.TestCase):
-    """اختبار محلل المخاطر"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.config = AppConfig()
-        self.risk_analyzer = RiskAnalyzer(self.config)
-    
-    def test_analyze_risks(self):
-        """اختبار تحليل المخاطر"""
-        # تحليل المخاطر
-        result = self.risk_analyzer.analyze_risks(1, "comprehensive")
-        self.assertTrue(result)
-        
-        # انتظار اكتمال التحليل
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.risk_analyzer.analysis_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # التحقق من نتائج التحليل
-        self.assertFalse(self.risk_analyzer.analysis_in_progress)
-        results = self.risk_analyzer.get_analysis_results()
-        self.assertEqual(results["status"], "اكتمل التحليل")
-        self.assertEqual(results["project_id"], 1)
-        self.assertEqual(results["method"], "comprehensive")
-        
-        # التحقق من وجود المخاطر المحددة
-        self.assertIn("identified_risks", results)
-        self.assertTrue(len(results["identified_risks"]) > 0)
-        
-        # التحقق من وجود فئات المخاطر
-        self.assertIn("risk_categories", results)
-        
-        # التحقق من وجود مصفوفة المخاطر
-        self.assertIn("risk_matrix", results)
-        
-        # التحقق من وجود استراتيجيات التخفيف
-        self.assertIn("mitigation_strategies", results)
-        self.assertTrue(len(results["mitigation_strategies"]) > 0)
-        
-        # التحقق من وجود ملخص التحليل
-        self.assertIn("summary", results)
-        self.assertIn("overall_risk_level", results["summary"])
-
-
-class TestAIAssistant(unittest.TestCase):
-    """اختبار المساعد الذكي"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.config = AppConfig()
-        self.assistant = AIAssistant(self.config)
-    
-    def test_process_query(self):
-        """اختبار معالجة الاستعلام"""
-        # معالجة استعلام
-        query = "كيف يمكنني تحليل مستند مناقصة؟"
-        result = self.assistant.process_query(query)
-        self.assertTrue(result)
-        
-        # انتظار اكتمال المعالجة
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.assistant.processing_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # التحقق من نتائج المعالجة
-        self.assertFalse(self.assistant.processing_in_progress)
-        results = self.assistant.get_processing_results()
-        self.assertEqual(results["status"], "اكتملت المعالجة")
-        self.assertEqual(results["query"], query)
-        
-        # التحقق من وجود استجابة
-        self.assertIn("response", results)
-        self.assertTrue(len(results["response"]) > 0)
-        
-        # التحقق من وجود اقتراحات
-        self.assertIn("suggestions", results)
-        self.assertTrue(len(results["suggestions"]) > 0)
-    
-    def test_conversation_history(self):
-        """اختبار سجل المحادثة"""
-        # معالجة استعلام
-        query = "ما هي استراتيجيات التسعير المتاحة؟"
-        self.assistant.process_query(query)
-        
-        # انتظار اكتمال المعالجة
-        import time
-        max_wait = 5  # ثوانٍ
-        waited = 0
-        while self.assistant.processing_in_progress and waited < max_wait:
-            time.sleep(0.5)
-            waited += 0.5
-        
-        # التحقق من سجل المحادثة
-        history = self.assistant.get_conversation_history()
-        self.assertEqual(len(history), 2)  # استعلام المستخدم واستجابة المساعد
-        self.assertEqual(history[0]["role"], "user")
-        self.assertEqual(history[0]["content"], query)
-        self.assertEqual(history[1]["role"], "assistant")
-        
-        # مسح سجل المحادثة
-        self.assertTrue(self.assistant.clear_conversation_history())
-        history = self.assistant.get_conversation_history()
-        self.assertEqual(len(history), 0)
-
-
-class TestStyling(unittest.TestCase):
-    """اختبار وحدات التصميم"""
-    
-    def test_app_theme(self):
-        """اختبار نمط التطبيق"""
-        theme = AppTheme()
-        
-        # التحقق من الألوان
-        self.assertIsNotNone(theme.get_color("bg_color"))
-        self.assertIsNotNone(theme.get_color("fg_color"))
-        
-        # التحقق من الخطوط
-        self.assertIsNotNone(theme.get_font("body"))
-        self.assertIsNotNone(theme.get_font("title"))
-        
-        # التحقق من الأحجام
-        self.assertIsNotNone(theme.get_size("padding_medium"))
-        self.assertIsNotNone(theme.get_size("border_radius"))
-        
-        # تغيير النمط
-        self.assertTrue(theme.set_theme("dark"))
-        self.assertEqual(theme.current_theme, "dark")
-        
-        # تغيير اللغة
-        self.assertTrue(theme.set_language("en"))
-        self.assertEqual(theme.current_language, "en")
-    
-    def test_icon_generator(self):
-        """اختبار مولد الأيقونات"""
-        icon_generator = IconGenerator()
-        
-        # توليد الأيقونات الافتراضية
-        icon_generator.generate_default_icons()
-        
-        # التحقق من وجود مجلد الأيقونات
-        self.assertTrue(Path('assets/icons').exists())
-        
-        # التحقق من وجود بعض الأيقونات
-        self.assertTrue(Path('assets/icons/dashboard.png').exists())
-        self.assertTrue(Path('assets/icons/projects.png').exists())
-    
-    def test_chart_generator(self):
-        """اختبار مولد الرسوم البيانية"""
-        theme = AppTheme()
-        chart_generator = ChartGenerator(theme)
-        
-        # إنشاء بيانات للرسم البياني الشريطي
-        bar_data = {
-            'labels': ['الربع الأول', 'الربع الثاني', 'الربع الثالث', 'الربع الرابع'],
-            'values': [15000, 20000, 18000, 25000]
-        }
-        
-        # إنشاء رسم بياني شريطي
-        fig = chart_generator.create_bar_chart(
-            bar_data,
-            'الإيرادات الفصلية',
-            'الفصل',
-            'الإيرادات (ريال)'
-        )
-        
-        # التحقق من إنشاء الرسم البياني
-        self.assertIsNotNone(fig)
-        
-        # حفظ الرسم البياني
-        save_path = 'test_chart.png'
-        chart_generator.create_bar_chart(
-            bar_data,
-            'الإيرادات الفصلية',
-            'الفصل',
-            'الإيرادات (ريال)',
-            save_path=save_path
-        )
-        
-        # التحقق من وجود ملف الرسم البياني
-        self.assertTrue(Path(save_path).exists())
-        
-        # حذف ملف الرسم البياني
-        if Path(save_path).exists():
-            Path(save_path).unlink()
-
-
-def run_tests():
-    """تشغيل الاختبارات"""
-    # إنشاء مجلد الاختبارات
-    test_dir = Path('test_results')
-    test_dir.mkdir(exist_ok=True)
-    
-    # إنشاء ملف لنتائج الاختبارات
-    test_results_file = test_dir / 'test_results.txt'
-    
-    # تشغيل الاختبارات وحفظ النتائج
-    with open(test_results_file, 'w', encoding='utf-8') as f:
-        runner = unittest.TextTestRunner(stream=f, verbosity=2)
-        suite = unittest.TestSuite()
-        
-        # إضافة اختبارات قاعدة البيانات
-        suite.addTest(unittest.makeSuite(TestDatabaseConnector))
-        suite.addTest(unittest.makeSuite(TestModels))
-        
-        # إضافة اختبارات الوحدات
-        suite.addTest(unittest.makeSuite(TestDocumentAnalyzer))
-        suite.addTest(unittest.makeSuite(TestPricingEngine))
-        suite.addTest(unittest.makeSuite(TestRiskAnalyzer))
-        suite.addTest(unittest.makeSuite(TestAIAssistant))
-        
-        # إضافة اختبارات التصميم
-        suite.addTest(unittest.makeSuite(TestStyling))
-        
-        # تشغيل الاختبارات
-        result = runner.run(suite)
-        
-        # كتابة ملخص النتائج
-        f.write("\n\n=== ملخص نتائج الاختبارات ===\n")
-        f.write(f"عدد الاختبارات: {result.testsRun}\n")
-        f.write(f"عدد النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}\n")
-        f.write(f"عدد الإخفاقات: {len(result.failures)}\n")
-        f.write(f"عدد الأخطاء: {len(result.errors)}\n")
-    
-    # طباعة ملخص النتائج
-    logger.info(f"تم تشغيل {result.testsRun} اختبار")
-    logger.info(f"النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}")
-    logger.info(f"الإخفاقات: {len(result.failures)}")
-    logger.info(f"الأخطاء: {len(result.errors)}")
-    logger.info(f"تم حفظ نتائج الاختبارات في: {test_results_file}")
-    
-    return result
-
-
-if __name__ == "__main__":
-    run_tests()

tests/test_integrated_system.py

@@ -1,96 +0,0 @@
-"""
-وحدة اختبار النظام المتكامل
-"""
-
-import unittest
-import os
-import sys
-from pathlib import Path
-
-# إضافة المسار الرئيسي للنظام
-sys.path.append(str(Path(__file__).parent.parent))
-
-# استيراد الوحدات
-from modules.pricing.pricing_app import PricingApp
-from modules.ai_assistant.ai_app import AIAssistantApp
-from modules.document_analysis.document_app import DocumentAnalysisApp
-from modules.data_analysis.data_analysis_app import DataAnalysisApp
-from modules.resources.resources_app import ResourcesApp
-
-class TestIntegratedSystem(unittest.TestCase):
-    """اختبارات النظام المتكامل"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        # التأكد من وجود جميع الملفات الرئيسية
-        self.main_files = [
-            "app.py",
-            "config.py",
-            "requirements.txt"
-        ]
-        
-        # التأكد من وجود جميع المجلدات الرئيسية
-        self.main_directories = [
-            "modules",
-            "assets",
-            "data",
-            "utils"
-        ]
-        
-        # التأكد من وجود جميع وحدات النظام
-        self.modules = [
-            "modules/pricing",
-            "modules/ai_assistant",
-            "modules/document_analysis",
-            "modules/data_analysis",
-            "modules/resources",
-            "modules/project_management",
-            "modules/reports",
-            "modules/risk_analysis"
-        ]
-    
-    def test_main_files_exist(self):
-        """اختبار وجود الملفات الرئيسية"""
-        for file in self.main_files:
-            file_path = Path(__file__).parent.parent / file
-            self.assertTrue(file_path.exists(), f"الملف {file} غير موجود")
-    
-    def test_main_directories_exist(self):
-        """اختبار وجود المجلدات الرئيسية"""
-        for directory in self.main_directories:
-            dir_path = Path(__file__).parent.parent / directory
-            self.assertTrue(dir_path.exists(), f"المجلد {directory} غير موجود")
-    
-    def test_modules_exist(self):
-        """اختبار وجود وحدات النظام"""
-        for module in self.modules:
-            module_path = Path(__file__).parent.parent / module
-            self.assertTrue(module_path.exists(), f"الوحدة {module} غير موجودة")
-    
-    def test_pricing_module(self):
-        """اختبار وحدة التسعير"""
-        pricing_app = PricingApp()
-        self.assertIsNotNone(pricing_app, "فشل إنشاء وحدة التسعير")
-    
-    def test_ai_assistant_module(self):
-        """اختبار وحدة الذكاء الاصطناعي"""
-        ai_app = AIAssistantApp()
-        self.assertIsNotNone(ai_app, "فشل إنشاء وحدة الذكاء الاصطناعي")
-    
-    def test_document_analysis_module(self):
-        """اختبار وحدة تحليل المستندات"""
-        document_app = DocumentAnalysisApp()
-        self.assertIsNotNone(document_app, "فشل إنشاء وحدة تحليل المستندات")
-    
-    def test_data_analysis_module(self):
-        """اختبار وحدة تحليل البيانات"""
-        data_analysis_app = DataAnalysisApp()
-        self.assertIsNotNone(data_analysis_app, "فشل إنشاء وحدة تحليل البيانات")
-    
-    def test_resources_module(self):
-        """اختبار وحدة الموارد"""
-        resources_app = ResourcesApp()
-        self.assertIsNotNone(resources_app, "فشل إنشاء وحدة الموارد")
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_ui.py

@@ -1,413 +0,0 @@
-"""
-وحدة اختبار واجهة المستخدم لنظام إدارة المناقصات - Hybrid Face
-"""
-
-import os
-import sys
-import logging
-import unittest
-import tkinter as tk
-import customtkinter as ctk
-from pathlib import Path
-
-# تهيئة السجل
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger('test_ui')
-
-# إضافة المسار الرئيسي للتطبيق إلى مسار البحث
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# استيراد الوحدات المطلوبة للاختبار
-from styling.theme import AppTheme
-from styling.icons import IconGenerator
-from styling.charts import ChartGenerator
-from config import AppConfig
-
-class TestUIComponents(unittest.TestCase):
-    """اختبار مكونات واجهة المستخدم"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.root = ctk.CTk()
-        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
-        self.theme = AppTheme()
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        self.root.destroy()
-    
-    def test_styled_frame(self):
-        """اختبار الإطار المنسق"""
-        frame = self.theme.create_styled_frame(self.root)
-        self.assertIsNotNone(frame)
-        self.assertEqual(frame.cget("fg_color"), self.theme.get_color("card_bg_color"))
-        self.assertEqual(frame.cget("corner_radius"), self.theme.get_size("border_radius"))
-    
-    def test_styled_button(self):
-        """اختبار الزر المنسق"""
-        button = self.theme.create_styled_button(self.root, "زر اختبار")
-        self.assertIsNotNone(button)
-        self.assertEqual(button.cget("text"), "زر اختبار")
-        self.assertEqual(button.cget("fg_color"), self.theme.get_color("button_bg_color"))
-        self.assertEqual(button.cget("text_color"), self.theme.get_color("button_fg_color"))
-    
-    def test_styled_label(self):
-        """اختبار التسمية المنسقة"""
-        label = self.theme.create_styled_label(self.root, "تسمية اختبار")
-        self.assertIsNotNone(label)
-        self.assertEqual(label.cget("text"), "تسمية اختبار")
-        self.assertEqual(label.cget("text_color"), self.theme.get_color("fg_color"))
-    
-    def test_styled_entry(self):
-        """اختبار حقل الإدخال المنسق"""
-        entry = self.theme.create_styled_entry(self.root, "نص توضيحي")
-        self.assertIsNotNone(entry)
-        self.assertEqual(entry.cget("placeholder_text"), "نص توضيحي")
-        self.assertEqual(entry.cget("fg_color"), self.theme.get_color("input_bg_color"))
-        self.assertEqual(entry.cget("text_color"), self.theme.get_color("input_fg_color"))
-    
-    def test_styled_combobox(self):
-        """اختبار القائمة المنسدلة المنسقة"""
-        values = ["الخيار الأول", "الخيار الثاني", "الخيار الثالث"]
-        combobox = self.theme.create_styled_combobox(self.root, values)
-        self.assertIsNotNone(combobox)
-        self.assertEqual(combobox.cget("values"), values)
-        self.assertEqual(combobox.cget("fg_color"), self.theme.get_color("input_bg_color"))
-        self.assertEqual(combobox.cget("text_color"), self.theme.get_color("input_fg_color"))
-    
-    def test_styled_checkbox(self):
-        """اختبار خانة الاختيار المنسقة"""
-        checkbox = self.theme.create_styled_checkbox(self.root, "خانة اختبار")
-        self.assertIsNotNone(checkbox)
-        self.assertEqual(checkbox.cget("text"), "خانة اختبار")
-        self.assertEqual(checkbox.cget("fg_color"), self.theme.get_color("button_bg_color"))
-        self.assertEqual(checkbox.cget("text_color"), self.theme.get_color("fg_color"))
-    
-    def test_styled_radio_button(self):
-        """اختبار زر الراديو المنسق"""
-        var = ctk.StringVar(value="1")
-        radio_button = self.theme.create_styled_radio_button(self.root, "زر راديو اختبار", var, "1")
-        self.assertIsNotNone(radio_button)
-        self.assertEqual(radio_button.cget("text"), "زر راديو اختبار")
-        self.assertEqual(radio_button.cget("fg_color"), self.theme.get_color("button_bg_color"))
-        self.assertEqual(radio_button.cget("text_color"), self.theme.get_color("fg_color"))
-    
-    def test_styled_switch(self):
-        """اختبار مفتاح التبديل المنسق"""
-        switch = self.theme.create_styled_switch(self.root, "مفتاح اختبار")
-        self.assertIsNotNone(switch)
-        self.assertEqual(switch.cget("text"), "مفتاح اختبار")
-        self.assertEqual(switch.cget("progress_color"), self.theme.get_color("button_bg_color"))
-        self.assertEqual(switch.cget("text_color"), self.theme.get_color("fg_color"))
-    
-    def test_styled_slider(self):
-        """اختبار شريط التمرير المنسق"""
-        slider = self.theme.create_styled_slider(self.root)
-        self.assertIsNotNone(slider)
-        self.assertEqual(slider.cget("fg_color"), self.theme.get_color("input_border_color"))
-        self.assertEqual(slider.cget("progress_color"), self.theme.get_color("button_bg_color"))
-    
-    def test_styled_progressbar(self):
-        """اختبار شريط التقدم المنسق"""
-        progressbar = self.theme.create_styled_progressbar(self.root)
-        self.assertIsNotNone(progressbar)
-        self.assertEqual(progressbar.cget("fg_color"), self.theme.get_color("input_border_color"))
-        self.assertEqual(progressbar.cget("progress_color"), self.theme.get_color("button_bg_color"))
-    
-    def test_styled_tabview(self):
-        """اختبار عرض التبويب المنسق"""
-        tabview = self.theme.create_styled_tabview(self.root)
-        self.assertIsNotNone(tabview)
-        self.assertEqual(tabview.cget("fg_color"), self.theme.get_color("card_bg_color"))
-    
-    def test_styled_scrollable_frame(self):
-        """اختبار الإطار القابل للتمرير المنسق"""
-        scrollable_frame = self.theme.create_styled_scrollable_frame(self.root)
-        self.assertIsNotNone(scrollable_frame)
-        self.assertEqual(scrollable_frame.cget("fg_color"), "transparent")
-    
-    def test_styled_textbox(self):
-        """اختبار مربع النص المنسق"""
-        textbox = self.theme.create_styled_textbox(self.root)
-        self.assertIsNotNone(textbox)
-        self.assertEqual(textbox.cget("fg_color"), self.theme.get_color("input_bg_color"))
-        self.assertEqual(textbox.cget("text_color"), self.theme.get_color("input_fg_color"))
-    
-    def test_styled_card(self):
-        """اختبار البطاقة المنسقة"""
-        card, content_frame = self.theme.create_styled_card(self.root, "بطاقة اختبار")
-        self.assertIsNotNone(card)
-        self.assertIsNotNone(content_frame)
-        self.assertEqual(card.cget("fg_color"), self.theme.get_color("card_bg_color"))
-    
-    def test_styled_data_table(self):
-        """اختبار جدول البيانات المنسق"""
-        columns = ["العمود الأول", "العمود الثاني", "العمود الثالث"]
-        data = [
-            ["بيانات 1-1", "بيانات 1-2", "بيانات 1-3"],
-            ["بيانات 2-1", "بيانات 2-2", "بيانات 2-3"]
-        ]
-        table_frame, data_frame = self.theme.create_styled_data_table(self.root, columns, data)
-        self.assertIsNotNone(table_frame)
-        self.assertIsNotNone(data_frame)
-        self.assertEqual(table_frame.cget("fg_color"), self.theme.get_color("card_bg_color"))
-    
-    def test_theme_switching(self):
-        """اختبار تبديل النمط"""
-        # تعيين النمط الفاتح
-        self.theme.set_theme("light")
-        light_bg_color = self.theme.get_color("bg_color")
-        
-        # تعيين النمط الداكن
-        self.theme.set_theme("dark")
-        dark_bg_color = self.theme.get_color("bg_color")
-        
-        # التحقق من اختلاف الألوان
-        self.assertNotEqual(light_bg_color, dark_bg_color)
-    
-    def test_language_switching(self):
-        """اختبار تبديل اللغة"""
-        # تعيين اللغة العربية
-        self.theme.set_language("ar")
-        ar_font = self.theme.get_font("body")
-        
-        # تعيين اللغة الإنجليزية
-        self.theme.set_language("en")
-        en_font = self.theme.get_font("body")
-        
-        # التحقق من اختلاف الخطوط
-        self.assertNotEqual(ar_font[0], en_font[0])
-
-
-class TestUILayout(unittest.TestCase):
-    """اختبار تخطيط واجهة المستخدم"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.root = ctk.CTk()
-        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
-        self.theme = AppTheme()
-        
-        # إنشاء الإطار الرئيسي
-        self.main_frame = self.theme.create_styled_frame(self.root)
-        self.main_frame.pack(fill="both", expand=True)
-        
-        # إنشاء الشريط الجانبي
-        self.sidebar_frame = self.theme.create_styled_frame(
-            self.main_frame,
-            fg_color=self.theme.get_color("sidebar_bg_color")
-        )
-        self.sidebar_frame.pack(side="left", fill="y", padx=0, pady=0)
-        
-        # إنشاء إطار المحتوى
-        self.content_frame = self.theme.create_styled_frame(
-            self.main_frame,
-            fg_color=self.theme.get_color("bg_color")
-        )
-        self.content_frame.pack(side="right", fill="both", expand=True, padx=0, pady=0)
-    
-    def tearDown(self):
-        """تنظيف بيئة الاخ��بار"""
-        self.root.destroy()
-    
-    def test_sidebar_layout(self):
-        """اختبار تخطيط الشريط الجانبي"""
-        # إنشاء شعار التطبيق
-        logo_label = self.theme.create_styled_label(
-            self.sidebar_frame,
-            "نظام إدارة المناقصات",
-            font=self.theme.get_font("title"),
-            text_color=self.theme.get_color("sidebar_fg_color")
-        )
-        logo_label.pack(padx=20, pady=20)
-        
-        # إنشاء أزرار الشريط الجانبي
-        sidebar_buttons = []
-        button_texts = [
-            "لوحة التحكم", "المشاريع", "المستندات", "التسعير",
-            "الموارد", "المخاطر", "التقارير", "الذكاء الاصطناعي"
-        ]
-        
-        for text in button_texts:
-            button_frame, button = self.theme.create_styled_sidebar_button(
-                self.sidebar_frame,
-                text
-            )
-            button_frame.pack(fill="x", padx=0, pady=2)
-            sidebar_buttons.append(button)
-        
-        # التحقق من إنشاء الأزرار
-        self.assertEqual(len(sidebar_buttons), len(button_texts))
-        for i, button in enumerate(sidebar_buttons):
-            self.assertEqual(button.cget("text"), button_texts[i])
-    
-    def test_content_layout(self):
-        """اختبار تخطيط المحتوى"""
-        # إنشاء شريط العنوان
-        header_frame = self.theme.create_styled_frame(
-            self.content_frame,
-            fg_color=self.theme.get_color("card_bg_color")
-        )
-        header_frame.pack(fill="x", padx=20, pady=20)
-        
-        # إنشاء عنوان الصفحة
-        page_title = self.theme.create_styled_label(
-            header_frame,
-            "لوحة التحكم",
-            font=self.theme.get_font("title")
-        )
-        page_title.pack(side="left", padx=20, pady=20)
-        
-        # إنشاء زر البحث
-        search_button = self.theme.create_styled_button(
-            header_frame,
-            "بحث"
-        )
-        search_button.pack(side="right", padx=20, pady=20)
-        
-        # إنشاء إطار البطاقات
-        cards_frame = self.theme.create_styled_frame(
-            self.content_frame,
-            fg_color="transparent"
-        )
-        cards_frame.pack(fill="both", expand=True, padx=20, pady=20)
-        
-        # إنشاء بطاقات
-        cards = []
-        card_titles = [
-            "المشاريع النشطة", "المناقصات الجديدة", "المخاطر العالية", "التقارير المعلقة"
-        ]
-        
-        for i, title in enumerate(card_titles):
-            card, card_content = self.theme.create_styled_card(
-                cards_frame,
-                title
-            )
-            card.grid(row=i//2, column=i%2, padx=10, pady=10, sticky="nsew")
-            cards.append(card)
-        
-        # التحقق من إنشاء البطاقات
-        self.assertEqual(len(cards), len(card_titles))
-        
-        # تهيئة أوزان الصفوف والأعمدة
-        cards_frame.grid_columnconfigure(0, weight=1)
-        cards_frame.grid_columnconfigure(1, weight=1)
-        cards_frame.grid_rowconfigure(0, weight=1)
-        cards_frame.grid_rowconfigure(1, weight=1)
-    
-    def test_responsive_layout(self):
-        """اختبار التخطيط المتجاوب"""
-        # تغيير حجم النافذة
-        self.root.geometry("800x600")
-        self.root.update()
-        
-        # التحقق من أن الإطار الرئيسي يملأ النافذة
-        self.assertEqual(self.main_frame.winfo_width(), 800)
-        self.assertEqual(self.main_frame.winfo_height(), 600)
-        
-        # تغيير حجم النافذة مرة أخرى
-        self.root.geometry("1024x768")
-        self.root.update()
-        
-        # التحقق من أن الإطار الرئيسي يملأ النافذة
-        self.assertEqual(self.main_frame.winfo_width(), 1024)
-        self.assertEqual(self.main_frame.winfo_height(), 768)
-
-
-class TestUIArabicSupport(unittest.TestCase):
-    """اختبار دعم اللغة العربية في واجهة المستخدم"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.root = ctk.CTk()
-        self.root.withdraw()  # إخفاء النافذة أثناء الاختبار
-        self.theme = AppTheme()
-        self.theme.set_language("ar")  # تعيين اللغة العربية
-    
-    def tearDown(self):
-        """تنظيف بيئة الاختبار"""
-        self.root.destroy()
-    
-    def test_arabic_text_display(self):
-        """اختبار عرض النص العربي"""
-        # إنشاء تسمية بنص عربي
-        arabic_text = "هذا نص عربي للاختبار"
-        label = self.theme.create_styled_label(self.root, arabic_text)
-        self.assertEqual(label.cget("text"), arabic_text)
-        
-        # إنشاء زر بنص عربي
-        button = self.theme.create_styled_button(self.root, "زر باللغة العربية")
-        self.assertEqual(button.cget("text"), "زر باللغة العربية")
-        
-        # إنشاء حقل إدخال بنص توضيحي عربي
-        entry = self.theme.create_styled_entry(self.root, "أدخل النص هنا")
-        self.assertEqual(entry.cget("placeholder_text"), "أدخل النص هنا")
-    
-    def test_arabic_font(self):
-        """اختبار الخط العربي"""
-        # التحقق من استخدام خط يدعم العربية
-        ar_font = self.theme.get_font("body")
-        self.assertEqual(ar_font[0], "Cairo")
-    
-    def test_rtl_support(self):
-        """اختبار دعم الكتابة من اليمين إلى اليسار"""
-        # إنشاء إطار
-        frame = self.theme.create_styled_frame(self.root)
-        frame.pack(fill="both", expand=True)
-        
-        # إنشاء تسمية بنص عربي
-        label = self.theme.create_styled_label(frame, "نص عربي من اليمين إلى اليسار")
-        label.pack(anchor="e", padx=20, pady=20)  # محاذاة إلى اليمين
-        
-        # التحقق من المحاذاة
-        self.assertEqual(label.cget("anchor"), "w")  # w تعني غرب (يسار)، لكن النص سيظهر من اليمين إلى اليسار
-
-
-def run_ui_tests():
-    """تشغيل اختبارات واجهة المستخدم"""
-    # إنشاء مجلد الاختبارات
-    test_dir = Path('test_results')
-    test_dir.mkdir(exist_ok=True)
-    
-    # إنشاء ملف لنتائج الاختبارات
-    test_results_file = test_dir / 'ui_test_results.txt'
-    
-    # تشغيل الاختبارات وحفظ النتائج
-    with open(test_results_file, 'w', encoding='utf-8') as f:
-        runner = unittest.TextTestRunner(stream=f, verbosity=2)
-        suite = unittest.TestSuite()
-        
-        # إضافة اختبارات مكونات واجهة المستخدم
-        suite.addTest(unittest.makeSuite(TestUIComponents))
-        
-        # إضافة اختبارات تخطيط واجهة المستخدم
-        suite.addTest(unittest.makeSuite(TestUILayout))
-        
-        # إضافة اختبارات دعم اللغة العربية
-        suite.addTest(unittest.makeSuite(TestUIArabicSupport))
-        
-        # تشغيل الاختبارات
-        result = runner.run(suite)
-        
-        # كتابة ملخص النتائج
-        f.write("\n\n=== ملخص نتائج اختبارات واجهة المستخدم ===\n")
-        f.write(f"عدد الاختبارات: {result.testsRun}\n")
-        f.write(f"عدد النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}\n")
-        f.write(f"عدد الإخفاقات: {len(result.failures)}\n")
-        f.write(f"عدد الأخطاء: {len(result.errors)}\n")
-    
-    # طباعة ملخص النتائج
-    logger.info(f"تم تشغيل {result.testsRun} اختبار لواجهة المستخدم")
-    logger.info(f"النجاحات: {result.testsRun - len(result.failures) - len(result.errors)}")
-    logger.info(f"الإخفاقات: {len(result.failures)}")
-    logger.info(f"الأخطاء: {len(result.errors)}")
-    logger.info(f"تم حفظ نتائج الاختبارات في: {test_results_file}")
-    
-    return result
-
-
-if __name__ == "__main__":
-    run_ui_tests()

tests/unit/test_reports.py

@@ -1,200 +0,0 @@
-"""
-اختبارات وحدة تقارير المشاريع
-"""
-
-import unittest
-import pandas as pd
-import numpy as np
-import sys
-import os
-from datetime import datetime, timedelta
-
-# إضافة المسار الرئيسي للمشروع لاستيراد الوحدات
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
-
-from modules.reports.reports_app import ReportsApp
-
-
-class TestReportsApp(unittest.TestCase):
-    """اختبارات وحدة لتطبيق التقارير"""
-    
-    def setUp(self):
-        """إعداد بيئة الاختبار"""
-        self.reports_app = ReportsApp()
-        
-        # إنشاء بيانات محاكاة للمشاريع
-        self.mock_projects = [
-            {
-                'id': 1,
-                'name': 'مشروع 1',
-                'number': 'T-2024001',
-                'client': 'وزارة الصحة',
-                'location': 'الرياض',
-                'status': 'جديد',
-                'submission_date': '2024-01-15',
-                'tender_type': 'عامة',
-                'created_at': '2024-01-10'
-            },
-            {
-                'id': 2,
-                'name': 'مشروع 2',
-                'number': 'T-2024002',
-                'client': 'وزارة التعليم',
-                'location': 'جدة',
-                'status': 'قيد التسعير',
-                'submission_date': '2024-01-28',
-                'tender_type': 'خاصة',
-                'created_at': '2024-01-20'
-            },
-            {
-                'id': 3,
-                'name': 'مشروع 3',
-                'number': 'T-2024003',
-                'client': 'وزارة الصحة',
-                'location': 'الدمام',
-                'status': 'تم التقديم',
-                'submission_date': '2024-02-10',
-                'tender_type': 'عامة',
-                'created_at': '2024-02-01'
-            },
-            {
-                'id': 4,
-                'name': 'مشروع 4',
-                'number': 'T-2024004',
-                'client': 'شركة أرامكو',
-                'location': 'الظهران',
-                'status': 'تمت الترسية',
-                'submission_date': '2024-02-15',
-                'tender_type': 'عامة',
-                'created_at': '2024-02-05'
-            },
-            {
-                'id': 5,
-                'name': 'مشروع 5',
-                'number': 'T-2024005',
-                'client': 'شركة سابك',
-                'location': 'الجبيل',
-                'status': 'قيد التنفيذ',
-                'submission_date': '2024-02-20',
-                'tender_type': 'خاصة',
-                'created_at': '2024-02-10'
-            }
-        ]
-    
-    def test_get_total_projects(self):
-        """اختبار حساب إجمالي عدد المشاريع"""
-        # تعيين المشاريع في حالة الجلسة
-        import streamlit as st
-        st.session_state.projects = self.mock_projects
-        
-        # اختبار الدالة
-        total = self.reports_app._get_total_projects()
-        self.assertEqual(total, 5)
-    
-    def test_get_active_projects(self):
-        """اختبار حساب عدد المشاريع النشطة"""
-        # تعيين المشاريع في حالة الجلسة
-        import streamlit as st
-        st.session_state.projects = self.mock_projects
-        
-        # اختبار الدالة
-        active = self.reports_app._get_active_projects()
-        self.assertEqual(active, 4)  # جميع المشاريع باستثناء الجديدة أو المنتهية أو الملغية
-    
-    def test_get_won_projects(self):
-        """اختبار حساب عدد المشاريع المرساة"""
-        # تعيين المشاريع في حالة الجلسة
-        import streamlit as st
-        st.session_state.projects = self.mock_projects
-        
-        # اختبار الدالة
-        won = self.reports_app._get_won_projects()
-        self.assertEqual(won, 2)  # المشاريع المرساة وقيد التنفيذ والمنتهية
-    
-    def test_get_project_status_data(self):
-        """اختبار الحصول على بيانات توزيع المشاريع حسب الحالة"""
-        # تعيين المشاريع في حالة الجلسة
-        import streamlit as st
-        st.session_state.projects = self.mock_projects
-        
-        # اختبار الدالة
-        status_data = self.reports_app._get_project_status_data()
-        
-        self.assertIsInstance(status_data, pd.DataFrame)
-        self.assertEqual(len(status_data), 5)  # 5 حالات مختلفة
-        
-        # التحقق من أن عدد المشاريع لكل حالة صحيح
-        status_counts = status_data.set_index('status')['count'].to_dict()
-        self.assertEqual(status_counts['جديد'], 1)
-        self.assertEqual(status_counts['قيد التسعير'], 1)
-        self.assertEqual(status_counts['تم التقديم'], 1)
-        self.assertEqual(status_counts['تمت الترسية'], 1)
-        self.assertEqual(status_counts['قيد التنفيذ'], 1)
-    
-    def test_get_monthly_project_data(self):
-        """اختبار الحصول على بيانات اتجاه المشاريع الشهري"""
-        # اختبار الدالة
-        monthly_data = self.reports_app._get_monthly_project_data()
-        
-        self.assertIsInstance(monthly_data, pd.DataFrame)
-        self.assertEqual(len(monthly_data), 6)  # 6 أشهر
-        
-        # التحقق من وجود الأعمدة المطلوبة
-        self.assertIn('month', monthly_data.columns)
-        self.assertIn('new', monthly_data.columns)
-        self.assertIn('submitted', monthly_data.columns)
-        self.assertIn('won', monthly_data.columns)
-    
-    def test_get_project_value_data(self):
-        """اختبار الحصول على بيانات توزيع قيم المشاريع"""
-        # اختبار الدالة
-        value_data = self.reports_app._get_project_value_data()
-        
-        self.assertIsInstance(value_data, pd.DataFrame)
-        self.assertEqual(len(value_data), 7)  # 7 نطاقات قيمة
-        
-        # التحقق من وجود الأعمدة المطلوبة
-        self.assertIn('range', value_data.columns)
-        self.assertIn('count', value_data.columns)
-    
-    def test_generate_sample_data(self):
-        """اختبار توليد البيانات العشوائية للمحاكاة"""
-        # مشاريع
-        project_fields = ["اسم المشروع", "رقم المناقصة", "العميل", "الموقع", "الحالة"]
-        project_data = self.reports_app._generate_sample_data("المشاريع", project_fields, 10)
-        
-        self.assertIsInstance(project_data, pd.DataFrame)
-        self.assertEqual(len(project_data), 10)
-        for field in project_fields:
-            self.assertIn(field, project_data.columns)
-        
-        # تسعير
-        pricing_fields = ["اسم المشروع", "رقم البند", "وصف البند", "الكمية", "سعر الوحدة"]
-        pricing_data = self.reports_app._generate_sample_data("التسعير", pricing_fields, 10)
-        
-        self.assertIsInstance(pricing_data, pd.DataFrame)
-        self.assertEqual(len(pricing_data), 10)
-        for field in pricing_fields:
-            self.assertIn(field, pricing_data.columns)
-        
-        # مخاطر
-        risk_fields = ["اسم المشروع", "رمز المخاطرة", "وصف المخاطرة", "الفئة"]
-        risk_data = self.reports_app._generate_sample_data("المخاطر", risk_fields, 10)
-        
-        self.assertIsInstance(risk_data, pd.DataFrame)
-        self.assertEqual(len(risk_data), 10)
-        for field in risk_fields:
-            self.assertIn(field, risk_data.columns)
-        
-        # محتوى محلي
-        local_content_fields = ["اسم المشروع", "الفئة", "البند", "المورد", "التكلفة"]
-        local_content_data = self.reports_app._generate_sample_data("المحتوى المحلي", local_content_fields, 10)
-        
-        self.assertIsInstance(local_content_data, pd.DataFrame)
-        self.assertEqual(len(local_content_data), 10)
-        for field in local_content_fields:
-            self.assertIn(field, local_content_data.columns)
-
-
-if __name__ == '__main__':
-    unittest.main()