Add run_pattern_instance_task

Signed-off-by: Alina Buzachis <[email protected]>

Author: alinabuzachis

core/task_runner.py

@@ -1,11 +1,20 @@
 import json
 import logging
 import os
+from contextlib import closing
 
+from core.utils.controller import assign_execute_roles
 from core.utils.controller import build_collection_uri
+from core.utils.controller import create_execution_environment
+from core.utils.controller import create_job_templates
+from core.utils.controller import create_labels
+from core.utils.controller import create_project
 from core.utils.controller import download_collection
+from core.utils.controller import get_http_session
+from core.utils.controller import save_instance_state
 
 from .models import Pattern
+from .models import PatternInstance
 from .models import Task
 
 logger = logging.getLogger(__name__)
@@ -55,3 +64,35 @@ def run_pattern_task(pattern_id: int, task_id: int) -> None:
         error_message = f"An unexpected error occurred {str(e)}."
         logger.exception(f"Task {task_id} failed unexpectedly.")
         task.mark_failed({"error": error_message})
+
+
+def run_pattern_instance_task(instance_id: int, task_id: int) -> None:
+    task = Task.objects.get(id=task_id)
+    try:
+        instance = PatternInstance.objects.select_related("pattern").get(id=instance_id)
+        pattern = instance.pattern
+        pattern_def = pattern.pattern_definition
+
+        if not pattern_def:
+            raise ValueError("Pattern definition is missing.")
+
+        # Create a single session for all AAP calls
+        with closing(get_http_session()) as session:
+            task.mark_running({"info": "Creating controller project"})
+            project_id = create_project(session, instance, pattern)
+            task.mark_running({"info": "Creating execution environment"})
+            ee_id = create_execution_environment(session, instance, pattern_def)
+            task.mark_running({"info": "Creating labels"})
+            labels = create_labels(session, instance, pattern_def)
+            task.mark_running({"info": "Creating job templates"})
+            automations = create_job_templates(
+                session, instance, pattern_def, project_id, ee_id
+            )
+            task.mark_running({"info": "Saving instance"})
+            save_instance_state(instance, project_id, ee_id, labels, automations)
+            task.mark_running({"info": "Assigning roles"})
+            assign_execute_roles(session, instance.executors, automations)
+            task.mark_completed({"info": "PatternInstance processed"})
+    except Exception as e:
+        logger.exception("Failed to process PatternInstance.")
+        task.mark_failed({"error": str(e)})

core/tests/test_controller_client.py

@@ -1,3 +1,9 @@
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pytest
+import requests
+
 import core.utils.controller.client as cc
 
 
@@ -6,3 +12,49 @@ def test_get_http_session():
     s1 = cc.get_http_session()
     s2 = cc.get_http_session()
     assert s1 is not s2
+
+
+def _fake_response(status_code: int, payload: dict | list) -> requests.Response:
+    """Return a Response-like mock that behaves for raise_for_status/json."""
+    resp = MagicMock(spec=requests.Response)
+    resp.status_code = status_code
+    resp.json.return_value = payload
+
+    if 400 <= status_code < 600:
+        http_error = requests.HTTPError(response=resp)
+        resp.raise_for_status.side_effect = http_error
+    else:
+        resp.raise_for_status.return_value = None
+    return resp
+
+
+@patch("core.utils.controller.client.get_http_session")
+def test_post_non_400_error_is_propagated(mock_get_http_session):
+    """
+    Test that a non-400 error is also immediately propagated.
+    """
+    session = MagicMock()
+    session.post.return_value = _fake_response(500, {"error": "server"})
+    mock_get_http_session.return_value = session
+
+    with pytest.raises(requests.HTTPError):
+        cc.post(session, "/labels/", {"name": "foo"})
+
+    session.get.assert_not_called()
+    session.post.assert_called_once()
+
+
+@patch("core.utils.controller.client.get_http_session")
+def test_post_success(mock_get_http_session):
+    """
+    Test that a successful POST request returns the JSON response.
+    """
+    session = MagicMock()
+    session.post.return_value = _fake_response(201, {"id": 123, "name": "foo"})
+    mock_get_http_session.return_value = session
+
+    out = cc.post(session, "/labels/", {"name": "foo"})
+    assert out == {"id": 123, "name": "foo"}
+
+    session.get.assert_not_called()
+    session.post.assert_called_once()