test_app.py

"""
Test script for Simple Project Management System
Basic functionality tests
"""

import unittest
import os
import tempfile
from app import app, db
from models import User, Project, Task, ActivityLog
from werkzeug.security import generate_password_hash

class SPMSTestCase(unittest.TestCase):
    """Test cases for SPMS application"""
    
    def setUp(self):
        """Set up test environment"""
        self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
        app.config['TESTING'] = True
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
        self.app = app.test_client()
        
        with app.app_context():
            db.create_all()
            
            # Create test users
            self.admin = User(
                username='test_admin',
                email='admin@test.com',
                password_hash=generate_password_hash('password'),
                role='admin'
            )
            self.manager = User(
                username='test_manager',
                email='manager@test.com',
                password_hash=generate_password_hash('password'),
                role='project_manager'
            )
            self.member = User(
                username='test_member',
                email='member@test.com',
                password_hash=generate_password_hash('password'),
                role='team_member'
            )
            
            db.session.add(self.admin)
            db.session.add(self.manager)
            db.session.add(self.member)
            db.session.commit()
    
    def tearDown(self):
        """Clean up after tests"""
        os.close(self.db_fd)
        os.unlink(app.config['DATABASE'])
    
    def test_user_creation(self):
        """Test user creation"""
        with app.app_context():
            user = User(
                username='test_user',
                email='user@test.com',
                password_hash=generate_password_hash('password'),
                role='team_member'
            )
            db.session.add(user)
            db.session.commit()
            
            created_user = User.query.filter_by(username='test_user').first()
            self.assertIsNotNone(created_user)
            self.assertEqual(created_user.email, 'user@test.com')
    
    def test_project_creation(self):
        """Test project creation"""
        with app.app_context():
            project = Project(
                name='Test Project',
                description='Test project description',
                start_date='2024-01-01',
                end_date='2024-12-31',
                status='active',
                created_by=self.manager.id
            )
            db.session.add(project)
            db.session.commit()
            
            created_project = Project.query.filter_by(name='Test Project').first()
            self.assertIsNotNone(created_project)
            self.assertEqual(created_project.created_by, self.manager.id)
    
    def test_task_creation(self):
        """Test task creation"""
        with app.app_context():
            # Create project first
            project = Project(
                name='Test Project',
                description='Test project description',
                start_date='2024-01-01',
                end_date='2024-12-31',
                status='active',
                created_by=self.manager.id
            )
            db.session.add(project)
            db.session.commit()
            
            # Create task
            task = Task(
                title='Test Task',
                description='Test task description',
                status='To Do',
                priority='medium',
                project_id=project.id,
                assigned_to=self.member.id
            )
            db.session.add(task)
            db.session.commit()
            
            created_task = Task.query.filter_by(title='Test Task').first()
            self.assertIsNotNone(created_task)
            self.assertEqual(created_task.assigned_to, self.member.id)
    
    def test_activity_logging(self):
        """Test activity logging"""
        with app.app_context():
            # Create project and task
            project = Project(
                name='Test Project',
                description='Test project description',
                start_date='2024-01-01',
                end_date='2024-12-31',
                status='active',
                created_by=self.manager.id
            )
            db.session.add(project)
            db.session.commit()
            
            task = Task(
                title='Test Task',
                description='Test task description',
                status='To Do',
                priority='medium',
                project_id=project.id,
                assigned_to=self.member.id
            )
            db.session.add(task)
            db.session.commit()
            
            # Create activity log
            activity = ActivityLog(
                task_id=task.id,
                user_id=self.member.id,
                action='created',
                message='Task created'
            )
            db.session.add(activity)
            db.session.commit()
            
            created_activity = ActivityLog.query.filter_by(task_id=task.id).first()
            self.assertIsNotNone(created_activity)
            self.assertEqual(created_activity.action, 'created')
    
    def test_user_permissions(self):
        """Test user permission system"""
        with app.app_context():
            # Test admin permissions
            self.assertTrue(self.admin.has_permission('create_project'))
            self.assertTrue(self.admin.has_permission('delete_project'))
            self.assertTrue(self.admin.has_permission('manage_users'))
            
            # Test manager permissions
            self.assertTrue(self.manager.has_permission('create_project'))
            self.assertFalse(self.manager.has_permission('manage_users'))
            
            # Test member permissions
            self.assertFalse(self.member.has_permission('create_project'))
            self.assertTrue(self.member.has_permission('view_assigned_tasks'))
    
    def test_project_progress_calculation(self):
        """Test project progress calculation"""
        with app.app_context():
            # Create project
            project = Project(
                name='Test Project',
                description='Test project description',
                start_date='2024-01-01',
                end_date='2024-12-31',
                status='active',
                created_by=self.manager.id
            )
            db.session.add(project)
            db.session.commit()
            
            # Create tasks with different statuses
            task1 = Task(
                title='Task 1',
                description='Completed task',
                status='Done',
                priority='medium',
                project_id=project.id,
                assigned_to=self.member.id
            )
            task2 = Task(
                title='Task 2',
                description='In progress task',
                status='In Progress',
                priority='medium',
                project_id=project.id,
                assigned_to=self.member.id
            )
            task3 = Task(
                title='Task 3',
                description='To do task',
                status='To Do',
                priority='medium',
                project_id=project.id,
                assigned_to=self.member.id
            )
            
            db.session.add(task1)
            db.session.add(task2)
            db.session.add(task3)
            db.session.commit()
            
            # Test progress calculation (1 out of 3 tasks completed = 33.33%)
            progress = project.progress_percentage
            self.assertEqual(progress, 33.33)
    
    def test_task_overdue_detection(self):
        """Test overdue task detection"""
        with app.app_context():
            from datetime import datetime, timedelta
            
            # Create project
            project = Project(
                name='Test Project',
                description='Test project description',
                start_date='2024-01-01',
                end_date='2024-12-31',
                status='active',
                created_by=self.manager.id
            )
            db.session.add(project)
            db.session.commit()
            
            # Create overdue task
            overdue_date = (datetime.now() - timedelta(days=5)).date()
            overdue_task = Task(
                title='Overdue Task',
                description='This task is overdue',
                status='To Do',
                priority='high',
                due_date=overdue_date,
                project_id=project.id,
                assigned_to=self.member.id
            )
            db.session.add(overdue_task)
            db.session.commit()
            
            # Test overdue detection
            self.assertTrue(overdue_task.is_overdue)
    
    def test_login_page_access(self):
        """Test login page accessibility"""
        response = self.app.get('/auth/login')
        self.assertEqual(response.status_code, 200)
    
    def test_dashboard_redirect(self):
        """Test dashboard redirect for unauthenticated users"""
        response = self.app.get('/')
        self.assertEqual(response.status_code, 302)  # Redirect to login
    
    def test_static_files(self):
        """Test static file serving"""
        # This would test if CSS and JS files are accessible
        # In a real test environment, you'd check for specific files
        pass

def run_tests():
    """Run all tests"""
    print("🧪 Running SPMS Test Suite...")
    print("=" * 50)
    
    # Create test suite
    suite = unittest.TestLoader().loadTestsFromTestCase(SPMSTestCase)
    
    # Run tests
    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(suite)
    
    # Print results
    print("\n" + "=" * 50)
    print(f"Tests run: {result.testsRun}")
    print(f"Failures: {len(result.failures)}")
    print(f"Errors: {len(result.errors)}")
    
    if result.failures:
        print("\n❌ Test Failures:")
        for test, traceback in result.failures:
            print(f"  - {test}: {traceback}")
    
    if result.errors:
        print("\n❌ Test Errors:")
        for test, traceback in result.errors:
            print(f"  - {test}: {traceback}")
    
    if result.wasSuccessful():
        print("\n✅ All tests passed!")
    else:
        print("\n❌ Some tests failed!")
    
    return result.wasSuccessful()

if __name__ == '__main__':
    run_tests()