004.erp.generic/backend/modules/task_management/tests/test_services.py

from django.test import TestCase
from django.contrib.auth import get_user_model
from unittest.mock import patch
from datetime import date
from rest_framework.exceptions import ValidationError
from modules.task_management.services import TaskService
from modules.task_management.exceptions import OpenWorkOrderBlockingTaskClose
from modules.task_management.models import Task, TaskTemplate, TaskTemplateEntry, TaskWorkEntry
from modules.fleet.models import Vehicle, WorkOrder, VehicleServiceRecord


class TaskServiceTests(TestCase):
    def setUp(self):
        User = get_user_model()
        self.user = User.objects.create_user(username="user1", email="u1@example.test", password="pass")
        self.other_user = User.objects.create_user(username="user2", email="u2@example.test", password="pass")
        self.staff = User.objects.create_user(username="admin", email="admin@example.test", password="pass", is_staff=True)

    def test_create_task_entry_creates_task_and_assigns_user(self):
        data = {"title": "Do work", "description": "Something", "status": "aktivan"}
        entry = TaskService.create_task_entry(data=data, user=self.user)
        assert isinstance(entry, Task)
        assert entry.assigned_to == self.user
        assert entry.title == "Do work"

    def test_create_task_entry_short_title_raises(self):
        data = {"title": "x", "description": "", "status": "aktivan"}
        with self.assertRaises(ValidationError):
            TaskService.create_task_entry(data=data, user=self.user)

    def test_update_task_entry_permission_denied_for_non_owner(self):
        task = Task.objects.create(title="T", description="", assigned_to=self.other_user)
        with self.assertRaises(ValidationError):
            TaskService.update_task_entry(instance=task, data={"title": "New"}, user=self.user)

    def test_update_task_entry_allowed_for_owner(self):
        task = Task.objects.create(title="Old", description="", assigned_to=self.user)
        updated = TaskService.update_task_entry(instance=task, data={"title": "New"}, user=self.user)
        assert updated.title == "New"

    def test_update_task_entry_rejects_closing_without_work_order(self):
        task = Task.objects.create(title="Za zatvaranje", description="", assigned_to=self.user, status='servis')
        with self.assertRaises(ValidationError):
            TaskService.update_task_entry(instance=task, data={"status": "neaktivan"}, user=self.user)

    def test_update_task_entry_allows_closing_with_work_order(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-01", asset_type='crane')
        work_order = WorkOrder.objects.create(
            vehicle=vehicle,
            creator=self.user,
            purpose='defektaza',
            status='closed',
            start_mileage=100,
            end_mileage=120,
        )
        task = Task.objects.create(title="Za zatvaranje", description="", assigned_to=self.user, status='servis')
        updated = TaskService.update_task_entry(
            instance=task,
            data={"status": "neaktivan", "work_order": work_order},
            user=self.user,
        )
        assert updated.status == "neaktivan"
        assert updated.work_order == work_order

    def test_update_task_entry_rejects_finished_without_work_order(self):
        task = Task.objects.create(title="Za završetak", description="", assigned_to=self.user, status='servis')
        with self.assertRaises(ValidationError):
            TaskService.update_task_entry(instance=task, data={"status": "zavrsen"}, user=self.user)

    def test_update_task_entry_allows_finished_with_work_order(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-01A", asset_type='crane')
        work_order = WorkOrder.objects.create(
            vehicle=vehicle,
            creator=self.user,
            purpose='kontrola',
            status='closed',
            start_mileage=100,
            end_mileage=150,
        )
        task = Task.objects.create(title="Za završetak", description="", assigned_to=self.user, status='servis', vehicle=vehicle)
        updated = TaskService.update_task_entry(
            instance=task,
            data={"status": "zavrsen", "work_order": work_order},
            user=self.user,
        )
        assert updated.status == "zavrsen"
        assert updated.work_order == work_order

    def test_update_task_entry_blocks_closing_when_work_order_open(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-01B", asset_type='crane')
        work_order = WorkOrder.objects.create(vehicle=vehicle, creator=self.user, purpose='kontrola', status='open')
        task = Task.objects.create(
            title="Integritet",
            description="",
            assigned_to=self.user,
            status='servis',
            vehicle=vehicle,
            work_order=work_order,
        )

        with self.assertRaises(OpenWorkOrderBlockingTaskClose):
            TaskService.update_task_entry(
                instance=task,
                data={"status": "zavrsen"},
                user=self.user,
            )

    def test_update_task_entry_can_auto_close_open_work_order(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-01C", asset_type='crane')
        work_order = WorkOrder.objects.create(
            vehicle=vehicle,
            creator=self.user,
            purpose='kontrola',
            status='open',
            start_mileage=100,
            end_mileage=150,
        )
        task = Task.objects.create(
            title="Auto close",
            description="",
            assigned_to=self.user,
            status='servis',
            vehicle=vehicle,
            work_order=work_order,
        )
        updated = TaskService.update_task_entry(
            instance=task,
            data={"status": "zavrsen"},
            user=self.user,
            auto_close_work_order=True,
        )
        work_order.refresh_from_db()
        self.assertEqual(updated.status, "zavrsen")
        self.assertEqual(work_order.status, "closed")

    def test_create_task_entry_from_template_creates_service_records(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-02", asset_type='crane')
        template = TaskTemplate.objects.create(
            code='template-servis-zapisi',
            title='Template servis',
            description='Opis templatea',
            status='aktivan',
        )
        TaskTemplateEntry.objects.create(
            task_template=template,
            sort_order=1,
            title='Pregled sustava',
            work_description='Provjera hidraulike',
            active_faults='Greška E101',
            explanation_hr='Prevedeno i objašnjeno.',
        )
        TaskTemplateEntry.objects.create(
            task_template=template,
            sort_order=2,
            title='Zamjena senzora',
            work_description='Zamijenjen senzor kuta',
            active_faults='',
            explanation_hr='Senzor kalibriran.',
        )

        created = TaskService.create_task_entry(
            data={'template_id': template.id, 'vehicle': vehicle},
            user=self.user,
        )

        self.assertEqual(created.vehicle_id, vehicle.id)
        self.assertEqual(TaskWorkEntry.objects.filter(task=created).count(), 2)
        records = VehicleServiceRecord.objects.filter(task=created).order_by('created_at')
        self.assertEqual(records.count(), 2)
        self.assertEqual(records.first().service_title, 'Pregled sustava')
        self.assertIn('Obrazloženje (HR): Prevedeno i objašnjeno.', records.first().description)
        self.assertIn('Aktivne greške: Greška E101', records.first().description)
        self.assertEqual(records.first().performed_by_id, self.user.id)

    def test_create_task_entry_from_template_limits_service_records_to_ten(self):
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-03", asset_type='crane')
        template = TaskTemplate.objects.create(
            code='template-limit-10',
            title='Template limit',
            description='Opis',
            status='aktivan',
        )
        for index in range(1, 13):
            TaskTemplateEntry.objects.create(
                task_template=template,
                sort_order=index,
                title=f'Korak {index}',
                work_description=f'Opis {index}',
            )

        created = TaskService.create_task_entry(
            data={'template_id': template.id, 'vehicle': vehicle},
            user=self.user,
        )

        self.assertEqual(TaskWorkEntry.objects.filter(task=created).count(), 10)
        self.assertEqual(VehicleServiceRecord.objects.filter(task=created).count(), 10)

    @patch('modules.fleet.services.NotificationService.create_notification')
    def test_create_task_entry_sends_overload_notifications_after_two_tasks(self, mock_notify):
        servicer = get_user_model().objects.create_user(
            username='servicer-overload',
            email='servicer-overload@example.test',
            password='test1234',
            is_serviser=True,
            is_team_member=True,
        )
        supervisor = get_user_model().objects.create_user(
            username='supervisor-overload',
            email='supervisor-overload@example.test',
            password='test1234',
            is_team_member=True,
            is_serviser=False,
        )
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-OVER1", asset_type='crane')
        scheduled = date(2026, 7, 21)

        Task.objects.create(title="Postojeći 1", assigned_to=servicer, vehicle=vehicle, status='aktivan', scheduled_date=scheduled)
        Task.objects.create(title="Postojeći 2", assigned_to=servicer, vehicle=vehicle, status='servis', scheduled_date=scheduled)

        TaskService.create_task_entry(
            data={
                "title": "Treći task",
                "status": "aktivan",
                "assigned_to": servicer,
                "vehicle": vehicle,
                "scheduled_date": scheduled,
            },
            user=self.staff,
        )

        recipients = [call.kwargs.get('recipient') for call in mock_notify.call_args_list]
        recipient_ids = {str(recipient.id) for recipient in recipients if recipient}
        self.assertIn(str(servicer.id), recipient_ids)
        self.assertIn(str(supervisor.id), recipient_ids)

    @patch('modules.fleet.services.NotificationService.create_notification')
    def test_create_task_entry_does_not_send_overload_notifications_when_two_or_less(self, mock_notify):
        servicer = get_user_model().objects.create_user(
            username='servicer-normal-load',
            email='servicer-normal-load@example.test',
            password='test1234',
            is_serviser=True,
            is_team_member=True,
        )
        vehicle = Vehicle.objects.create(registration_number="ZG-TASK-OVER2", asset_type='crane')
        scheduled = date(2026, 7, 21)

        TaskService.create_task_entry(
            data={
                "title": "Prvi task",
                "status": "aktivan",
                "assigned_to": servicer,
                "vehicle": vehicle,
                "scheduled_date": scheduled,
            },
            user=self.staff,
        )
        TaskService.create_task_entry(
            data={
                "title": "Drugi task",
                "status": "aktivan",
                "assigned_to": servicer,
                "vehicle": vehicle,
                "scheduled_date": scheduled,
            },
            user=self.staff,
        )
        self.assertEqual(mock_notify.call_count, 0)