Wire pattern creation tasks to dispatcher

core/tasks/common.py

@@ -0,0 +1 @@
+DISPATCHERD_DEFAULT_CHANNEL = "pattern-service-tasks"

core/tasks/demo.py

@@ -1,7 +1,7 @@
 from dispatcherd.publish import submit_task
 from dispatcherd.publish import task
 
-DISPATCHERD_DEFAULT_CHANNEL = "pattern-service-tasks"
+from core.tasks.common import DISPATCHERD_DEFAULT_CHANNEL
 
 
 @task(queue=DISPATCHERD_DEFAULT_CHANNEL, decorate=False)

core/task_runner.py → core/tasks/pattern.py

@@ -3,6 +3,12 @@
 import os
 from contextlib import closing
 
+from dispatcherd.publish import task
+
+from core.models import Pattern
+from core.models import PatternInstance
+from core.models import Task
+from core.tasks.common import DISPATCHERD_DEFAULT_CHANNEL
 from core.utils.controller import assign_execute_roles
 from core.utils.controller import build_collection_uri
 from core.utils.controller import create_execution_environment
@@ -13,14 +19,11 @@
 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__)
 
 
-def run_pattern_task(pattern_id: int, task_id: int) -> None:
+@task(queue=DISPATCHERD_DEFAULT_CHANNEL, decorate=False)
+def pattern_create(pattern_id: int, task_id: int) -> None:
     """
     Orchestrates downloading a collection and saving a pattern definition.
 
@@ -66,7 +69,8 @@ def run_pattern_task(pattern_id: int, task_id: int) -> None:
         task.mark_failed({"error": error_message})
 
 
-def run_pattern_instance_task(instance_id: int, task_id: int) -> None:
+@task(queue=DISPATCHERD_DEFAULT_CHANNEL, decorate=False)
+def pattern_instance_create(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)

core/tests/conftest.py

@@ -13,6 +13,7 @@ def client():
 
 @pytest.fixture()
 def automation(db, pattern_instance) -> models.Automation:
+    models.Automation.objects.all().delete()
     automation = models.Automation.objects.create(
         automation_type=api_examples.automation_get_response.value["automation_type"],
         automation_id=api_examples.automation_get_response.value["automation_id"],
@@ -24,6 +25,7 @@ def automation(db, pattern_instance) -> models.Automation:
 
 @pytest.fixture()
 def controller_label(db) -> models.ControllerLabel:
+    models.ControllerLabel.objects.all().delete()
     controller_label = models.ControllerLabel.objects.create(
         label_id=api_examples.controller_label_get_response.value["label_id"]
     )
@@ -32,6 +34,7 @@ def controller_label(db) -> models.ControllerLabel:
 
 @pytest.fixture()
 def pattern(db) -> models.Pattern:
+    models.Pattern.objects.all().delete()
     pattern = models.Pattern.objects.create(
         collection_name=api_examples.pattern_post_request.value["collection_name"],
         collection_version=api_examples.pattern_post_request.value[
@@ -44,6 +47,7 @@ def pattern(db) -> models.Pattern:
 
 @pytest.fixture()
 def pattern_instance(db, pattern) -> models.PatternInstance:
+    models.PatternInstance.objects.all().delete()
     pattern_instance = models.PatternInstance.objects.create(
         credentials=api_examples.pattern_instance_post_request.value["credentials"],
         executors=api_examples.pattern_instance_post_request.value["executors"],
@@ -55,6 +59,7 @@ def pattern_instance(db, pattern) -> models.PatternInstance:
 
 @pytest.fixture()
 def task(db) -> models.Task:
+    models.Task.objects.all().delete()
     task = models.Task.objects.create(
         status=api_examples.task_get_response.value["status"],
         details=api_examples.task_get_response.value["details"],

core/tests/integration/test_pattern.py

@@ -0,0 +1,22 @@
+import pytest
+from rest_framework import status
+from rest_framework.test import APIClient
+
+
+@pytest.mark.django_db
+def test_create_pattern():
+    client = APIClient()
+    data = {
+        "collection_name": "cloud.testing",
+        "collection_version": "4.3.2",
+        "pattern_name": "new_pattern",
+    }
+    response = client.post("/api/pattern-service/v1/patterns/", data, format="json")
+
+    assert response.status_code == status.HTTP_202_ACCEPTED
+    assert "task_id" in response.data
+    assert "message" in response.data
+    assert (
+        response.data["message"]
+        == "Pattern creation initiated. Check task status for progress."
+    )

core/tests/test_api_v1.py

@@ -1,3 +1,5 @@
+from unittest.mock import patch
+
 import pytest
 from freezegun import freeze_time
 from rest_framework import status
@@ -15,14 +17,50 @@ def test_retrieve_automation_success(client, automation):
     url = f"/api/pattern-service/v1/automations/{automation.pk}/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == api_examples.automation_get_response.value
+    expected = api_examples.automation_get_response.value
+    pattern_instance_id = response.json().get("pattern_instance")
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/automations/{automation.pk}/",
+            "id": automation.pk,
+            "pattern_instance": pattern_instance_id,
+            "related": {
+                "pattern_instance": (
+                    f"/api/pattern-service/v1/pattern_instances/{pattern_instance_id}/"
+                ),
+            },
+            "summary_fields": {"pattern_instance": {"id": 1}},
+        }
+    )
+    assert response.json() == expected
 
 
 def test_list_automations_success(client, automation):
     url = "/api/pattern-service/v1/automations/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == [api_examples.automation_get_response.value]
+    expected = api_examples.automation_get_response.value
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/automations/{automation.pk}/",
+            "id": automation.pk,
+        }
+    )
+    pattern_instance_id = response.json()[0].get("pattern_instance")
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/automations/{automation.pk}/",
+            "id": automation.pk,
+            "pattern_instance": pattern_instance_id,
+            "related": {
+                "pattern_instance": (
+                    f"/api/pattern-service/v1/pattern_instances/{pattern_instance_id}/"
+                ),
+            },
+            "summary_fields": {"pattern_instance": {"id": pattern_instance_id}},
+        }
+    )
+    assert response.json() == [expected]
 
 
 def test_retrieve_controller_label_success(client, controller_label):
@@ -36,65 +74,118 @@ def test_list_controller_labels_success(client, controller_label):
     url = "/api/pattern-service/v1/controller_labels/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == [api_examples.controller_label_get_response.value]
-
-
-def test_create_pattern_success(client, db):
+    expected = api_examples.controller_label_get_response.value
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/controller_labels/{controller_label.pk}/",
+            "id": controller_label.pk,
+        }
+    )
+    assert response.json() == [expected]
+
+
+@patch("core.views.submit_task", return_value=False)
+def test_create_pattern_success(mock_submit_task, client, db):
     url = "/api/pattern-service/v1/patterns/"
     data = api_examples.pattern_post_request.value
     response = client.post(url, data, format="json")
     assert response.status_code == status.HTTP_202_ACCEPTED
-    assert response.json() == api_examples.pattern_post_response.value
+    assert response.json().get(
+        "message"
+    ) == api_examples.pattern_post_response.value.get("message")
+    assert isinstance(response.json().get("task_id"), int)
 
 
 def test_retrieve_pattern_success(client, pattern):
     url = f"/api/pattern-service/v1/patterns/{pattern.pk}/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
+    expected = api_examples.pattern_get_response.value
+    expected.update(
+        {"url": f"/api/pattern-service/v1/patterns/{pattern.pk}/", "id": pattern.pk}
+    )
     assert response.json() == api_examples.pattern_get_response.value
 
 
 def test_list_patterns_success(client, pattern):
     url = "/api/pattern-service/v1/patterns/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == [api_examples.pattern_get_response.value]
+    expected = api_examples.pattern_get_response.value
+    expected.update(
+        {"url": f"/api/pattern-service/v1/patterns/{pattern.pk}/", "id": pattern.pk}
+    )
+    assert response.json() == [expected]
 
 
-def test_create_pattern_instance_success(client, pattern):
+@patch("core.views.submit_task", return_value=False)
+def test_create_pattern_instance_success(mock_submit_task, client, pattern):
     url = "/api/pattern-service/v1/pattern_instances/"
     data = api_examples.pattern_instance_post_request.value
     data["pattern"] = pattern.pk
     response = client.post(url, data, format="json")
     assert response.status_code == status.HTTP_202_ACCEPTED
-    assert response.json() == api_examples.pattern_instance_post_response.value
+    assert response.json().get(
+        "message"
+    ) == api_examples.pattern_instance_post_response.value.get("message")
+    assert isinstance(response.json().get("task_id"), int)
 
 
 def test_retrieve_pattern_instance_success(client, controller_label, pattern_instance):
     pattern_instance.controller_labels.add(controller_label)
     url = f"/api/pattern-service/v1/pattern_instances/{pattern_instance.pk}/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == api_examples.pattern_instance_get_response.value
+    pattern_id = response.json().get("pattern")
+    assert isinstance(pattern_id, int)
+    expected = api_examples.pattern_instance_get_response.value
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/pattern_instances/{pattern_instance.pk}/",
+            "id": pattern_instance.pk,
+            "controller_labels": [controller_label.id],
+            "summary_fields": {"pattern": {"id": pattern_id}},
+            "related": {"pattern": f"/api/pattern-service/v1/patterns/{pattern_id}/"},
+            "pattern": pattern_id,
+        }
+    )
+    assert response.json() == expected
 
 
 def test_list_pattern_instances_success(client, controller_label, pattern_instance):
     pattern_instance.controller_labels.add(controller_label)
     url = "/api/pattern-service/v1/pattern_instances/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == [api_examples.pattern_instance_get_response.value]
+    pattern_id = response.json()[0].get("pattern")
+    assert isinstance(pattern_id, int)
+    expected = api_examples.pattern_instance_get_response.value
+    expected.update(
+        {
+            "url": f"/api/pattern-service/v1/pattern_instances/{pattern_instance.pk}/",
+            "id": pattern_instance.pk,
+            "controller_labels": [controller_label.id],
+            "summary_fields": {"pattern": {"id": pattern_id}},
+            "related": {"pattern": f"/api/pattern-service/v1/patterns/{pattern_id}/"},
+            "pattern": pattern_id,
+        }
+    )
+    assert response.json() == [expected]
 
 
 def test_retrieve_task_success(client, task):
     url = f"/api/pattern-service/v1/tasks/{task.pk}/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
+    expected = api_examples.task_get_response.value
+    expected.update({"url": url, "id": task.pk})
     assert response.json() == api_examples.task_get_response.value
 
 
 def test_list_tasks_success(client, task):
     url = "/api/pattern-service/v1/tasks/"
     response = client.get(url)
     assert response.status_code == status.HTTP_200_OK
-    assert response.json() == [api_examples.task_get_response.value]
+    expected = api_examples.task_get_response.value
+    expected.update({"url": f"/api/pattern-service/v1/tasks/{task.pk}/", "id": task.pk})
+    assert response.json() == [expected]