prvi kod za live uporabu

backend/modules/task_management/tests/test_models.py

@@ -0,0 +1,12 @@
+from django.test import TestCase
+from django.contrib.auth import get_user_model
+
+from modules.task_management.models import Task
+
+
+class TaskModelTests(TestCase):
+    def test_str_returns_title_and_status(self):
+        user = get_user_model().objects.create_user(username="u1", email="u1@example.test", password="pass")
+        task = Task.objects.create(title="My Task", description="Desc", assigned_to=user)
+        assert str(task).startswith("My Task")
+        assert "aktivan" in str(task) or "(" in str(task)  # basic sanity

backend/modules/task_management/tests/test_serializers.py

@@ -0,0 +1,32 @@
+from django.test import TestCase
+from modules.task_management.serializers import TaskSerializer
+from rest_framework.exceptions import ValidationError
+from django.contrib.auth import get_user_model
+from modules.task_management.models import Task
+from modules.fleet.models import Vehicle, WorkOrder
+
+
+class TaskSerializerTests(TestCase):
+    def test_validate_title_too_short_raises(self):
+        serializer = TaskSerializer(data={"title": "ab", "description": "", "status": "aktivan"})
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_validate_title_ok(self):
+        serializer = TaskSerializer(data={"title": "Valid title", "description": "", "status": "aktivan"})
+        assert serializer.is_valid(), serializer.errors
+
+    def test_cannot_close_without_work_order(self):
+        serializer = TaskSerializer(data={"title": "Task 1", "description": "", "status": "neaktivan"})
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_can_close_with_work_order(self):
+        User = get_user_model()
+        user = User.objects.create_user(username="task-user", email="task-user@example.test", password="pass")
+        vehicle = Vehicle.objects.create(registration_number="ZG-TSK-02", asset_type='crane')
+        work_order = WorkOrder.objects.create(vehicle=vehicle, creator=user, purpose='defektaza')
+        task = Task.objects.create(title="Task 2", description="", status="servis", assigned_to=user)
+
+        serializer = TaskSerializer(instance=task, data={"status": "neaktivan", "work_order": str(work_order.id)}, partial=True)
+        assert serializer.is_valid(), serializer.errors

backend/modules/task_management/tests/test_services.py

@@ -0,0 +1,53 @@
+from django.test import TestCase
+from django.contrib.auth import get_user_model
+from rest_framework.exceptions import ValidationError
+from modules.task_management.services import TaskService
+from modules.task_management.models import Task
+from modules.fleet.models import Vehicle, WorkOrder
+
+
+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')
+        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

backend/modules/task_management/tests/test_tasks.py

@@ -0,0 +1,25 @@
+from django.test import TestCase
+from django.contrib.auth import get_user_model
+from modules.task_management.tasks import create_task_from_invoice
+from modules.task_management.models import Task
+
+
+class TaskCeleryTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        # Create an admin user to be assigned the task
+        self.admin = User.objects.create_user(username="admin", email="admin@example.test", password="pass", is_staff=True)
+
+    def test_create_task_from_invoice_creates_task_for_large_amount(self):
+        invoice_data = {"amount": 1500, "invoice_number": "INV-100"}
+        # run the task function synchronously via .run (no bind)
+        create_task_from_invoice.run(invoice_data)
+        task = Task.objects.filter(title__icontains="INV-100").first()
+        assert task is not None
+        assert task.assigned_to == self.admin
+
+    def test_create_task_from_invoice_does_not_create_for_small_amount(self):
+        invoice_data = {"amount": 100, "invoice_number": "INV-101"}
+        create_task_from_invoice.run(invoice_data)
+        task = Task.objects.filter(title__icontains="INV-101").first()
+        assert task is None

backend/modules/task_management/tests/test_views.py

@@ -0,0 +1,54 @@
+from django.test import TestCase, RequestFactory
+from django.contrib.auth import get_user_model
+from unittest.mock import patch
+
+from modules.task_management.views import TaskViewSet
+from modules.task_management.serializers import TaskSerializer
+from modules.task_management.models import Task
+
+
+class TaskViewSetTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user(username="u1", email="u1@example.test", password="pass")
+        self.factory = RequestFactory()
+        self.view = TaskViewSet()
+        self.view.request = self.factory.post("/")
+        self.view.request.user = self.user
+
+    @patch("modules.task_management.views.TaskService.create_task_entry")
+    def test_perform_create_calls_service(self, mock_create):
+        data = {"title": "Task from view", "description": "", "status": "aktivan"}
+        serializer = TaskSerializer(data=data, context={"request": self.view.request})
+        assert serializer.is_valid(), serializer.errors
+
+        # Call perform_create, which should delegate to TaskService.create_task_entry
+        self.view.perform_create(serializer)
+        mock_create.assert_called_once()
+        args, kwargs = mock_create.call_args
+        assert "data" in kwargs and kwargs["user"] == self.user
+
+    @patch("modules.task_management.views.TaskService.update_task_entry")
+    def test_perform_update_calls_service_and_saves(self, mock_update):
+        # Create an instance and use serializer to update
+        task = Task.objects.create(title="Old", description="", assigned_to=self.user)
+        data = {"title": "Updated", "description": "new", "status": "aktivan"}
+        serializer = TaskSerializer(instance=task, data=data, partial=True, context={"request": self.view.request})
+        assert serializer.is_valid(), serializer.errors
+
+        # attach view.request and instance then call perform_update
+        self.view.request = self.factory.put("/")
+        self.view.request.user = self.user
+        serializer.instance = task
+
+        self.view.perform_update(serializer)
+        mock_update.assert_called_once_with(instance=task, data=serializer.validated_data, user=self.view.request.user)
+        # confirm instance saved with new title
+        task.refresh_from_db()
+        assert task.title == "Updated"
+
+    def test_perform_destroy_soft_deletes(self):
+        task = Task.objects.create(title="ToDelete", description="", assigned_to=self.user)
+        self.view.perform_destroy(task)
+        task.refresh_from_db()
+        assert task.is_active is False