TimeTracker/tests/test_project_inactive_status.py

"""Tests for project inactive status functionality"""
import pytest
from app.models import Project


class TestProjectInactiveStatus:
    """Test project inactive status functionality"""
    
    @pytest.mark.models
    def test_project_default_status(self, app, test_client):
        """Test that new projects have active status by default"""
        from app import db
        
        project = Project(name='New Project', client_id=test_client.id)
        db.session.add(project)
        db.session.commit()
        
        assert project.status == 'active'
        assert project.is_active is True
    
    @pytest.mark.models
    def test_project_deactivate(self, app, project):
        """Test deactivating a project"""
        from app import db
        
        project.deactivate()
        db.session.commit()
        
        assert project.status == 'inactive'
        assert project.is_active is False
    
    @pytest.mark.models
    def test_project_activate_from_inactive(self, app, project):
        """Test activating an inactive project"""
        from app import db
        
        project.deactivate()
        db.session.commit()
        assert project.status == 'inactive'
        
        project.activate()
        db.session.commit()
        assert project.status == 'active'
        assert project.is_active is True
    
    @pytest.mark.models
    def test_project_archive_from_inactive(self, app, project):
        """Test archiving an inactive project"""
        from app import db
        
        project.deactivate()
        db.session.commit()
        assert project.status == 'inactive'
        
        project.archive()
        db.session.commit()
        assert project.status == 'archived'
    
    @pytest.mark.models
    def test_project_unarchive_to_active(self, app, project):
        """Test unarchiving a project returns it to active"""
        from app import db
        
        project.archive()
        db.session.commit()
        assert project.status == 'archived'
        
        project.unarchive()
        db.session.commit()
        assert project.status == 'active'
    
    @pytest.mark.models
    def test_project_status_transitions(self, app, project):
        """Test complete status transition cycle"""
        from app import db
        
        # Start active
        assert project.status == 'active'
        
        # Move to inactive
        project.deactivate()
        db.session.commit()
        assert project.status == 'inactive'
        
        # Move back to active
        project.activate()
        db.session.commit()
        assert project.status == 'active'
        
        # Move to archived
        project.archive()
        db.session.commit()
        assert project.status == 'archived'
        
        # Move back to active via unarchive
        project.unarchive()
        db.session.commit()
        assert project.status == 'active'


class TestProjectInactiveRoutes:
    """Test project inactive status routes"""
    
    @pytest.mark.routes
    def test_deactivate_project_route(self, admin_authenticated_client, app, project):
        """Test deactivating a project via route"""
        from app import db
        
        project_id = project.id
        
        response = admin_authenticated_client.post(f'/projects/{project_id}/deactivate', 
                               follow_redirects=True)
        
        assert response.status_code == 200
        
        db.session.refresh(project)
        assert project.status == 'inactive'
    
    @pytest.mark.routes
    def test_activate_project_route(self, admin_authenticated_client, app, project):
        """Test activating a project via route"""
        from app import db
        
        project.deactivate()
        db.session.commit()
        project_id = project.id
        
        response = admin_authenticated_client.post(f'/projects/{project_id}/activate',
                               follow_redirects=True)
        
        assert response.status_code == 200
        
        db.session.refresh(project)
        assert project.status == 'active'
    
    @pytest.mark.routes
    def test_filter_inactive_projects(self, admin_authenticated_client, app, test_client):
        """Test filtering projects by inactive status"""
        from app import db
        
        # Create multiple projects with different statuses
        active_project = Project(name='Active Project', client_id=test_client.id)
        inactive_project = Project(name='Inactive Project', client_id=test_client.id)
        archived_project = Project(name='Archived Project', client_id=test_client.id)
        
        db.session.add_all([active_project, inactive_project, archived_project])
        db.session.commit()
        
        inactive_project.deactivate()
        archived_project.archive()
        db.session.commit()
        
        # Test filter for inactive projects
        response = admin_authenticated_client.get('/projects?status=inactive')
        assert response.status_code == 200
        assert b'Inactive Project' in response.data
        assert b'Active Project' not in response.data
        assert b'Archived Project' not in response.data


class TestTaskDeletion:
    """Test task deletion functionality"""
    
    @pytest.mark.routes
    def test_task_list_has_bulk_delete_features(self, admin_authenticated_client, app, project, admin_user):
        """Test that task list shows bulk delete features"""
        from app.models import Task
        from app import db
        
        task = Task(
            name='Test Task',
            project_id=project.id,
            created_by=admin_user.id
        )
        db.session.add(task)
        db.session.commit()
        
        response = admin_authenticated_client.get('/tasks')
        assert response.status_code == 200
        # Should have bulk delete functionality
        assert b'bulkActionsBtn' in response.data
        assert b'selectAll' in response.data
        # Should also have task checkboxes for selection
        assert b'task-checkbox' in response.data