Reorg

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

Author: alinabuzachis

core/controller_client.py

@@ -0,0 +1,38 @@
+import logging
+from typing import Dict
+from typing import Iterator
+from typing import Optional
+
+import requests
+from requests import Session
+from requests.auth import HTTPBasicAuth
+
+from pattern_service.settings.aap import get_aap_settings
+
+logger = logging.getLogger(__name__)
+
+settings = get_aap_settings()
+
+_aap_session: Optional[Session] = None
+
+
+def get_http_session(force_refresh: bool = False) -> Session:
+    """Returns a cached Session instance with AAP credentials."""
+    global _aap_session
+    if _aap_session is None or force_refresh:
+        session = Session()
+        session.auth = HTTPBasicAuth(settings.username, settings.password)
+        session.verify = settings.verify_ssl
+        session.headers.update({'Content-Type': 'application/json'})
+        _aap_session = session
+
+    return _aap_session
+
+
+def get(path: str, *, params: Optional[Dict] = None) -> requests.Response:
+    session = get_http_session()
+    url = f"{settings.url}{path}"
+    response = session.get(url, params=params, stream=True)
+    response.raise_for_status()
+
+    return response

core/services.py

@@ -0,0 +1,77 @@
+import contextlib
+import io
+import json
+import logging
+import os
+import shutil
+import tarfile
+import tempfile
+from typing import Iterator
+
+from .controller_client import get
+from .models import Pattern
+from .models import Task
+
+logger = logging.getLogger(__name__)
+
+
+def update_task_status(task: Task, status_: str, details: dict):
+    task.status = status_
+    task.details = details
+    task.save()
+
+
+@contextlib.contextmanager
+def download_collection(collection: str, version: str) -> Iterator[str]:
+    """
+    Downloads and extracts a collection tarball to a temporary directory.
+
+    Args:
+        collection: The name of the collection (e.g., 'my_namespace.my_collection').
+        version: The version of the collection (e.g., '1.0.0').
+
+    Yields:
+        The path to the extracted collection files.
+    """
+    path = f"/api/galaxy/v3/plugin/ansible/content/published/collections/artifacts/{collection}-{version}.tar.gz"
+
+    temp_base_dir = tempfile.mkdtemp()
+    collection_path = os.path.join(temp_base_dir, f"{collection}-{version}")
+    os.makedirs(collection_path, exist_ok=True)
+
+    try:
+        response = get(path)
+        in_memory_tar = io.BytesIO(response.content)
+
+        with tarfile.open(fileobj=in_memory_tar, mode="r|*") as tar:
+            tar.extractall(path=collection_path, filter="data")
+
+        logger.info(f"Collection extracted to {collection_path}")
+        yield collection_path  # Yield the path to the caller
+    finally:
+        shutil.rmtree(temp_base_dir)
+
+
+def pattern_task(pattern_id: int, task_id: int):
+    """
+    Orchestrates downloading a collection and saving a pattern definition.
+    """
+    task = Task.objects.get(id=task_id)
+    try:
+        pattern = Pattern.objects.get(id=pattern_id)
+        update_task_status(task, "Running", {"info": "Processing pattern"})
+        with download_collection(pattern.collection_name.replace(".", "-"), pattern.collection_version) as collection_path:
+            path_to_definition = os.path.join(collection_path, "extensions", "patterns", pattern.pattern_name, "meta", "pattern.json")
+            with open(path_to_definition, "r") as file:
+                definition = json.load(file)
+
+            pattern.pattern_definition = definition
+            pattern.collection_version_uri = pattern.collection_version_uri
+            pattern.save(update_fields=["pattern_definition", "collection_version_uri"])
+        update_task_status(task, "Completed", {"info": "Pattern processed successfully"})
+    except FileNotFoundError:
+        logger.error(f"Could not find pattern definition for task {task_id}")
+        update_task_status(task, "Failed", {"error": "Pattern definition not found."})
+    except Exception as e:
+        logger.error(f"Task {task_id} failed: {e}")
+        update_task_status(task, "Failed", {"error": str(e)})

core/tasks.py

@@ -1,123 +1,5 @@
-import contextlib
-import io
-import json
-import logging
-import os
-import shutil
-import tarfile
-import tempfile
-import urllib.parse
-from typing import Dict
-from typing import Iterator
-from typing import Optional
+from core.services import pattern_task
 
-import requests
-from requests import Session
-from requests.auth import HTTPBasicAuth
 
-from pattern_service.settings.aap import get_aap_settings
-
-from .models import Pattern
-from .models import Task
-
-logger = logging.getLogger(__name__)
-
-settings = get_aap_settings()
-_aap_session: Optional[Session] = None
-
-
-def update_task_status(task: Task, status_: str, details: dict):
-    task.status = status_
-    task.details = details
-    task.save()
-
-
-@contextlib.contextmanager
-def download_collection(collection: str, version: str) -> Iterator[str]:
-    """
-    Downloads and extracts a collection tarball to a temporary directory.
-
-    Args:
-        collection: The name of the collection (e.g., 'my_namespace.my_collection').
-        version: The version of the collection (e.g., '1.0.0').
-
-    Yields:
-        The path to the extracted collection files.
-    """
-    path = f"/api/galaxy/v3/plugin/ansible/content/published/collections/artifacts/{collection}-{version}.tar.gz"
-
-    temp_base_dir = tempfile.mkdtemp()
-    collection_path = os.path.join(temp_base_dir, f"{collection}-{version}")
-    os.makedirs(collection_path, exist_ok=True)
-
-    try:
-        response = get(path)
-        in_memory_tar = io.BytesIO(response.content)
-
-        with tarfile.open(fileobj=in_memory_tar, mode="r|*") as tar:
-            tar.extractall(path=collection_path, filter="data")
-
-        logger.info(f"Collection extracted to {collection_path}")
-        yield collection_path  # Yield the path to the caller
-    finally:
-        shutil.rmtree(temp_base_dir)
-
-
-def get_http_session(force_refresh: bool = False) -> Session:
-    """Returns a cached Session instance with AAP credentials."""
-    global _aap_session
-    if _aap_session is None or force_refresh:
-        session = Session()
-        session.auth = HTTPBasicAuth(settings.username, settings.password)
-        session.verify = settings.verify_ssl
-        session.headers.update({'Content-Type': 'application/json'})
-        _aap_session = session
-
-    return _aap_session
-
-
-def get(path: str, *, params: Optional[Dict] = None) -> requests.Response:
-    session = get_http_session()
-    url = f"{settings.url}{path}"
-    response = session.get(url, params=params, stream=True)
-    response.raise_for_status()
-
-    return response
-
-
-def run_pattern_task(pattern_id: int, task_id: int):
-    """
-    Orchestrates downloading a collection and saving a pattern definition.
-    """
-    task = Task.objects.get(id=task_id)
-
-    try:
-        pattern = Pattern.objects.get(id=pattern_id)
-        update_task_status(task, "Running", {"info": "Processing pattern"})
-
-        # Get all necessary names from the pattern object
-        collection_name = pattern.collection_name.replace(".", "-")
-        collection_version = pattern.collection_version
-        pattern_name = pattern.pattern_name
-
-        update_task_status(task, "Running", {"info": "Downloading collection tarball"})
-
-        with download_collection(collection_name, collection_version) as collection_path:
-            path_to_definition = os.path.join(collection_path, "extensions", "patterns", pattern_name, "meta", "pattern.json")
-
-            with open(path_to_definition, "r") as file:
-                definition = json.load(file)
-
-            pattern.pattern_definition = definition
-            pattern.collection_version_uri = pattern.collection_version_uri
-            pattern.save(update_fields=["pattern_definition", "collection_version_uri"])
-
-        update_task_status(task, "Completed", {"info": "Pattern processed successfully"})
-
-    except FileNotFoundError:
-        logger.error(f"Could not find pattern definition for task {task_id}")
-        update_task_status(task, "Failed", {"error": "Pattern definition file not found in collection."})
-
-    except Exception as e:
-        logger.error(f"Task {task_id} failed: {e}")
-        update_task_status(task, "Failed", {"error": str(e)})
+def execute_pattern_task(pattern_id, task_id):
+    pattern_task(pattern_id, task_id)

core/tests/test_controller_client.py

@@ -0,0 +1,12 @@
+from core.controller_client import _aap_session
+from core.controller_client import get_http_session
+
+
+def test_get_http_session_caches():
+    """Subsequent calls without force_refresh must return the *same* object."""
+    s1 = get_http_session()
+    s2 = get_http_session()
+    assert s1 is s2
+
+    s3 = get_http_session(force_refresh=True)
+    assert s3 is not s1 and s3 is _aap_session

core/tests/test_tasks.py renamed to core/tests/test_services.py

@@ -12,7 +12,7 @@
 from core.models import Pattern
 from core.models import PatternInstance
 from core.models import Task
-from core.tasks import run_pattern_task
+from core.services import pattern_task
 
 
 class SharedDataMixin:
@@ -70,28 +70,62 @@ def tearDown(self):
         self.temp_dirs.clear()
 
 
-class TaskTests(SharedDataMixin, TestCase):
+class PatternTaskTest(SharedDataMixin, TestCase):
+    @patch("core.services.update_task_status", wraps=pattern_task.__globals__["update_task_status"])
+    @patch("core.services.open", new_callable=mock_open, read_data='{"name": "test"}')
+    @patch("core.services.download_collection")
+    def test_run_pattern_task_success(self, mock_download, mock_open_fn, mock_update_status):
+        pattern = Pattern.objects.create(
+            collection_name="demo.collection",
+            collection_version="1.0.0",
+            pattern_name="test_pattern",
+        )
+        task = Task.objects.create(status="Initiated", details={})
+        temp_dir = tempfile.mkdtemp()
+        mock_download.return_value.__enter__.return_value = temp_dir
+
+        os.makedirs(os.path.join(temp_dir, "extensions", "patterns", "test_pattern", "meta"))
+        with open(os.path.join(temp_dir, "extensions", "patterns", "test_pattern", "meta", "pattern.json"), "w") as f:
+            f.write(json.dumps({"name": "test"}))
+
+        pattern_task(pattern.id, task.id)
+
+        mock_update_status.assert_any_call(task, "Running", {"info": "Processing pattern"})
+        mock_update_status.assert_any_call(task, "Completed", {"info": "Pattern processed successfully"})
+
+    @patch("core.services.update_task_status", wraps=pattern_task.__globals__["update_task_status"])
+    @patch("core.services.download_collection", side_effect=FileNotFoundError)
+    def test_run_pattern_task_file_not_found(self, mock_download, mock_update_status):
+        pattern = Pattern.objects.create(
+            collection_name="demo.collection",
+            collection_version="1.0.0",
+            pattern_name="missing_pattern",
+        )
+        task = Task.objects.create(status="Initiated", details={})
+
+        pattern_task(pattern.id, task.id)
+
+        mock_update_status.assert_called_with(task, "Failed", {"error": "Pattern definition not found."})
 
-    @patch("core.tasks.download_collection", side_effect=Exception("Download failed"))
+    @patch("core.services.download_collection", side_effect=Exception("Download failed"))
     def test_run_pattern_task_handles_download_failure(self, mock_download):
-        run_pattern_task(self.pattern.id, self.task.id)
+        pattern_task(self.pattern.id, self.task.id)
         self.task.refresh_from_db()
         self.assertEqual(self.task.status, "Failed")
         self.assertIn("Download failed", self.task.details.get("error", ""))
 
-    @patch("core.tasks.update_task_status", wraps=run_pattern_task.__globals__["update_task_status"])
-    @patch("core.tasks.download_collection")
+    @patch("core.services.update_task_status", wraps=pattern_task.__globals__["update_task_status"])
+    @patch("core.services.download_collection")
     def test_full_status_update_flow(self, mock_download, mock_update_status):
         temp_dir_path = self.create_temp_collection_dir()
         mock_download.return_value.__enter__.return_value = temp_dir_path
 
         # Run the task
-        run_pattern_task(self.pattern.id, self.task.id)
+        pattern_task(self.pattern.id, self.task.id)
 
         # Verify calls to update_task_status
         expected_calls = [
             (self.task, "Running", {"info": "Processing pattern"}),
-            (self.task, "Running", {"info": "Downloading collection tarball"}),
             (self.task, "Completed", {"info": "Pattern processed successfully"}),
         ]
         actual_calls = [tuple(call.args) for call in mock_update_status.call_args_list]

core/tests/test_views.py

@@ -51,6 +51,14 @@ def setUpTestData(cls):
 
 
 class PatternViewSetTest(SharedDataMixin, APITestCase):
+    def setUp(self):
+        patcher = patch("core.services.update_task_status")
+        self.mock_update_status = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        # No-op to avoid context['request'] access
+        self.mock_update_status.side_effect = lambda task, status, details=None: (Task.objects.filter(pk=task.pk).update(status=status, details=details or {}))
+
     def create_temp_collection_dir(self):
         temp_dir = tempfile.mkdtemp()
         os.makedirs(os.path.join(temp_dir, "extensions", "patterns", "new_pattern", "meta"), exist_ok=True)
@@ -73,7 +81,7 @@ def test_pattern_detail_view(self):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data["collection_name"], "mynamespace.mycollection")
 
-    @patch("core.tasks.download_collection")
+    @patch("core.services.download_collection")
     def test_pattern_create_view(self, mock_download_collection):
         temp_dir = self.create_temp_collection_dir()  # Simulate a valid pattern.json
         mock_download_collection.return_value.__enter__.return_value = temp_dir

core/views.py

@@ -15,7 +15,7 @@
 from .serializers import PatternInstanceSerializer
 from .serializers import PatternSerializer
 from .serializers import TaskSerializer
-from .tasks import run_pattern_task
+from .tasks import pattern_task
 
 
 class CoreViewSet(AnsibleBaseView):
@@ -33,7 +33,7 @@ def create(self, request, *args, **kwargs):
 
         task = Task.objects.create(status="Initiated", details={"model": "Pattern", "id": pattern.id})
 
-        run_pattern_task(pattern.id, task.id)
+        pattern_task(pattern.id, task.id)
 
         headers = self.get_success_headers(serializer.data)
 
@@ -43,6 +43,7 @@ def create(self, request, *args, **kwargs):
                 "message": "Pattern creation initiated. Check task status for progress.",
             },
             status=status.HTTP_202_ACCEPTED,
+            headers=headers,
         )