add task response

Author: davidgamez

functions-python/tasks_executor/README.md

@@ -68,17 +68,6 @@ To update the geolocation files precision:
 }
 ```
 
-To populate license rules:
-
-```json
-{
-  "task": "populate_license_rules",
-  "payload": {
-    "dry_run": true
-  }
-}
-```
-
 To populate licenses:
 
 ```json

functions-python/tasks_executor/src/tasks/licenses/populate_license_rules.py

@@ -60,9 +60,10 @@ def populate_license_rules(dry_run, db_session):
         logging.info(
             "Loaded %d rules from %d categories.", len(rules_data), len(rules_json)
         )
-
+        result = ""
         if dry_run:
-            logging.info("Dry run: would insert/update %d rules.", len(rules_data))
+            result = "Dry run: would insert/update %d rules.", len(rules_data)
+            logging.info(result)
         else:
             for rule_data in rules_data:
                 rule_object = Rule(
@@ -73,9 +74,11 @@ def populate_license_rules(dry_run, db_session):
                 )
                 db_session.merge(rule_object)
 
-            logging.info(
-                "Successfully upserted %d rules into the database.", len(rules_data)
+            result = "Successfully upserted %d rules into the database.", len(
+                rules_data
             )
+            logging.info(result)
+        return result
 
     except requests.exceptions.RequestException as e:
         logging.error("Failed to download rules JSON file: %s", e)

functions-python/tasks_executor/src/tasks/licenses/populate_license_tags.py

@@ -74,12 +74,10 @@ def populate_license_tags(dry_run, db_session):
             len(tags_data),
         )
 
+        result = ""
         if dry_run:
-            logging.info(
-                "Dry run: would insert/update %d groups and %d tags.",
-                len(groups_data),
-                len(tags_data),
-            )
+            result = f"Dry run: would insert/update {len(groups_data)} groups and {len(tags_data)} tags."
+            logging.info(result)
         else:
             # Upsert groups first so FK from license_tag.group is satisfied
             for group in groups_data.values():
@@ -100,12 +98,10 @@ def populate_license_tags(dry_run, db_session):
                     url=tag_data["url"],
                 )
                 db_session.merge(tag_object)
-
-            logging.info(
-                "Successfully upserted %d groups and %d tags into the database.",
-                len(groups_data),
-                len(tags_data),
+            result = (
+                f"Successfully upserted {len(groups_data)} groups and {len(tags_data)} tags into the database.",
             )
+            logging.info(result)
 
     except requests.exceptions.RequestException as e:
         logging.error("Failed to download tags JSON file: %s", e)

functions-python/tasks_executor/src/tasks/licenses/populate_licenses.py

@@ -46,9 +46,14 @@ def populate_licenses_handler(payload):
         payload (dict): Incoming payload data.
     """
     dry_run = get_parameters(payload)
-    populate_license_rules(dry_run)
-    populate_license_tags(dry_run)
-    return populate_licenses_task(dry_run)
+    rules_result = populate_license_rules(dry_run)
+    tags_result = populate_license_tags(dry_run)
+    license_result = populate_licenses_task(dry_run)
+    return {
+        "rules": rules_result,
+        "tags": tags_result,
+        "licenses": license_result,
+    }
 
 
 @with_db_session
@@ -166,10 +171,9 @@ def populate_licenses_task(dry_run, db_session):
                 # including their rule and tag associations.
                 if not is_new:
                     db_session.merge(license_object)
-
-            logging.info(
-                "Successfully upserted licenses into the database.",
-            )
+            result = "Successfully upserted licenses into the database."
+            logging.info(result)
+            return result
 
     except requests.exceptions.RequestException as e:
         logging.error("Failed to download licenses JSON file: %s", e)

functions-python/tasks_executor/tests/tasks/populate_licenses_and_rules/test_populate_licenses.py

@@ -6,6 +6,7 @@
 from shared.database_gen.sqlacodegen_models import LicenseTag, Rule
 from tasks.licenses.populate_licenses import (
     LICENSES_API_URL,
+    populate_licenses_handler,
     populate_licenses_task,
 )
 
@@ -182,5 +183,122 @@ def test_request_exception_handling(self, mock_get):
         mock_db_session.rollback.assert_not_called()
 
 
+class TestPopulateLicensesHandler(unittest.TestCase):
+    """Tests for the populate_licenses_handler orchestration function."""
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_calls_all_subtasks_and_returns_combined_result(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """Handler should call all three sub-tasks and return a dict with their results."""
+        mock_rules.return_value = "rules_result"
+        mock_tags.return_value = "tags_result"
+        mock_licenses.return_value = "licenses_result"
+
+        result = populate_licenses_handler({"dry_run": False})
+
+        mock_rules.assert_called_once_with(False)
+        mock_tags.assert_called_once_with(False)
+        mock_licenses.assert_called_once_with(False)
+        self.assertEqual(
+            result,
+            {
+                "rules": "rules_result",
+                "tags": "tags_result",
+                "licenses": "licenses_result",
+            },
+        )
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_dry_run_passes_flag_to_subtasks(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """Handler should propagate dry_run=True to every sub-task."""
+        mock_rules.return_value = "Dry run: would insert/update 0 rules."
+        mock_tags.return_value = "Dry run: would insert/update 0 groups and 0 tags."
+        mock_licenses.return_value = None
+
+        result = populate_licenses_handler({"dry_run": True})
+
+        mock_rules.assert_called_once_with(True)
+        mock_tags.assert_called_once_with(True)
+        mock_licenses.assert_called_once_with(True)
+        self.assertEqual(result["rules"], "Dry run: would insert/update 0 rules.")
+        self.assertEqual(
+            result["tags"], "Dry run: would insert/update 0 groups and 0 tags."
+        )
+        self.assertIsNone(result["licenses"])
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_defaults_dry_run_to_false_when_missing(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """Handler should default dry_run to False when the key is absent from the payload."""
+        mock_rules.return_value = None
+        mock_tags.return_value = None
+        mock_licenses.return_value = None
+
+        populate_licenses_handler({})
+
+        mock_rules.assert_called_once_with(False)
+        mock_tags.assert_called_once_with(False)
+        mock_licenses.assert_called_once_with(False)
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_propagates_exception_from_rules(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """If populate_license_rules raises, the handler should propagate the exception
+        and the downstream sub-tasks should not be called."""
+        mock_rules.side_effect = requests.exceptions.RequestException("Network error")
+
+        with self.assertRaises(requests.exceptions.RequestException):
+            populate_licenses_handler({"dry_run": False})
+
+        mock_tags.assert_not_called()
+        mock_licenses.assert_not_called()
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_propagates_exception_from_tags(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """If populate_license_tags raises, the handler should propagate the exception
+        and populate_licenses_task should not be called."""
+        mock_rules.return_value = "rules_result"
+        mock_tags.side_effect = requests.exceptions.RequestException("Network error")
+
+        with self.assertRaises(requests.exceptions.RequestException):
+            populate_licenses_handler({"dry_run": False})
+
+        mock_licenses.assert_not_called()
+
+    @patch("tasks.licenses.populate_licenses.populate_licenses_task")
+    @patch("tasks.licenses.populate_licenses.populate_license_tags")
+    @patch("tasks.licenses.populate_licenses.populate_license_rules")
+    def test_handler_result_keys_are_always_present(
+        self, mock_rules, mock_tags, mock_licenses
+    ):
+        """The returned dict must always contain the three expected keys."""
+        mock_rules.return_value = None
+        mock_tags.return_value = None
+        mock_licenses.return_value = None
+
+        result = populate_licenses_handler({"dry_run": False})
+
+        self.assertIn("rules", result)
+        self.assertIn("tags", result)
+        self.assertIn("licenses", result)
+
+
 if __name__ == "__main__":
     unittest.main()