CDD-3447 - Fix faioing tests and coverage

Author: tushortz

cms/dynamic_content/blocks_deconstruction.py

@@ -438,13 +438,10 @@ def get_all_selected_topics_from_chart_blocks(
         """
         topics = set()
         for block in chart_blocks:
-            topic = (
-                block["static_fields"]["topic"]
-                if is_dual_category_chart_block(block)
-                else block["value"]["topic"]
-            )
-
-            topics.add(topic)
+            if is_dual_category_chart_block(block):
+                topics.add(block["static_fields"]["topic"])
+            else:
+                topics.update(plot["value"]["topic"] for plot in block["chart"])
 
         return topics
 

tests/conftest.py

@@ -439,6 +439,60 @@ def example_chart_block() -> dict[str, str | list[dict]]:
     }
 
 
+@pytest.fixture
+def example_dual_category_chart_block() -> dict[str, str | list[dict]]:
+    return {
+        "title": "Lead headline rates by age and sex",
+        "x_axis": "age",
+        "x_axis_title": "Age groups",
+        "primary_field_values": [
+            "00-01",
+            "01-04",
+            "05-09",
+            "05-11",
+            "05-14",
+            "10-14",
+        ],
+        "y_axis": "metric",
+        "y_axis_title": "Genders by age",
+        "y_axis_minimum_value": 0,
+        "y_axis_maximum_value": None,
+        "chart_type": "stacked_bar",
+        "static_fields": {
+            "topic": "Lead",
+            "metric": "lead_headline_ratesByAgeSex",
+            "geography": "England",
+            "geography_type": "Nation",
+            "sex": "all",
+            "age": "all",
+            "stratum": "default",
+            "date_from": "2020-05-21",
+            "date_to": "2026-05-21",
+        },
+        "secondary_category": "sex",
+        "segments": [
+            {
+                "type": "segment",
+                "value": {
+                    "secondary_field_value": "f",
+                    "colour": "COLOUR_1_DARK_BLUE",
+                    "label": "",
+                },
+                "id": "b0ead98b-4102-48f6-b94e-ff7bcffe1dc4",
+            },
+            {
+                "type": "segment",
+                "value": {
+                    "secondary_field_value": "m",
+                    "colour": "COLOUR_1_DARK_BLUE",
+                    "label": "Males",
+                },
+                "id": "c1fbe09c-5213-59f7-c05f-ff8cdffe2ed5",
+            },
+        ],
+    }
+
+
 @pytest.fixture
 def example_headline_chart_block() -> dict[str, str | list[dict]]:
     return {

tests/unit/caching/private_api/crawler/dynamic_block_crawler/test_process_individual_blocks.py

@@ -317,6 +317,115 @@ def test_process_download_for_chart_block_delegates_calls_successfully(
             data=expected_data
         )
 
+    def test_process_dual_category_chart_block_hits_dual_category_tables_endpoint(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+        dynamic_content_block_crawler_with_mocked_internal_api_client: DynamicContentBlockCrawler,
+    ):
+        """
+        Given a dual category chart block
+        When `process_chart_block()` is called
+            from an instance of `DynamicContentBlockCrawler`
+        Then the call is delegated to the `hit_dual_category_tables_endpoint()`
+            on the `InternalAPIClient`
+        """
+        # Given
+        spy_internal_api_client: mock.Mock = (
+            dynamic_content_block_crawler_with_mocked_internal_api_client._internal_api_client
+        )
+        request_payload_builder = (
+            dynamic_content_block_crawler_with_mocked_internal_api_client._request_payload_builder
+        )
+
+        # When
+        dynamic_content_block_crawler_with_mocked_internal_api_client.process_chart_block(
+            chart_block=example_dual_category_chart_block,
+        )
+
+        # Then
+        expected_tables_request_data = (
+            request_payload_builder.build_dual_category_tables_request_data(
+                chart_block=example_dual_category_chart_block
+            )
+        )
+        spy_internal_api_client.hit_dual_category_tables_endpoint.assert_called_once_with(
+            data=expected_tables_request_data
+        )
+
+    def test_process_dual_category_chart_block_hits_dual_category_charts_endpoint(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+        dynamic_content_block_crawler_with_mocked_internal_api_client: DynamicContentBlockCrawler,
+    ):
+        """
+        Given a dual category chart block
+        When `process_chart_block()` is called
+            from an instance of `DynamicContentBlockCrawler`
+        Then the call is delegated to the `hit_dual_category_charts_endpoint()`
+            on the `InternalAPIClient`
+        """
+        # Given
+        spy_internal_api_client: mock.Mock = (
+            dynamic_content_block_crawler_with_mocked_internal_api_client._internal_api_client
+        )
+        request_payload_builder = (
+            dynamic_content_block_crawler_with_mocked_internal_api_client._request_payload_builder
+        )
+
+        # When
+        dynamic_content_block_crawler_with_mocked_internal_api_client.process_chart_block(
+            chart_block=example_dual_category_chart_block,
+        )
+
+        # Then
+        expected_calls = [
+            mock.call(
+                data=request_payload_builder.build_dual_category_chart_request_data(
+                    chart_block=example_dual_category_chart_block,
+                    chart_is_double_width=chart_is_double_width,
+                )
+            )
+            for chart_is_double_width in (True, False)
+        ]
+        spy_internal_api_client.hit_dual_category_charts_endpoint.assert_has_calls(
+            calls=expected_calls, any_order=True
+        )
+
+    def test_process_download_for_dual_category_chart_block_delegates_calls_successfully(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+        dynamic_content_block_crawler_with_mocked_internal_api_client: DynamicContentBlockCrawler,
+    ):
+        """
+        Given a dual category chart block
+        When the `process_download_for_chart_block()` is called
+            from an instance of the `DynamicContentBlockCrawler`
+        Then the call is delegated to the `hit_dual_category_downloads_endpoint()`
+            on the `InternalAPIClient`
+        """
+        # Given
+        file_format = "json"
+        spy_internal_api_client: mock.Mock = (
+            dynamic_content_block_crawler_with_mocked_internal_api_client._internal_api_client
+        )
+        request_payload_builder = RequestPayloadBuilder()
+
+        # When
+        dynamic_content_block_crawler_with_mocked_internal_api_client.process_download_for_chart_block(
+            chart_block=example_dual_category_chart_block, file_format=file_format
+        )
+
+        # Then
+        expected_data: dict = (
+            request_payload_builder.build_dual_category_downloads_request_data(
+                chart_block=example_dual_category_chart_block,
+                file_format=file_format,
+            )
+        )
+        spy_internal_api_client.hit_dual_category_downloads_endpoint.assert_called_once_with(
+            data=expected_data
+        )
+
     def test_process_global_filter(
         self,
         example_global_filter: dict,

tests/unit/caching/private_api/crawler/test_request_payload_builder.py

@@ -1,4 +1,7 @@
 import pytest
+from copy import deepcopy
+from datetime import datetime
+from unittest import mock
 
 from caching.private_api.crawler.request_payload_builder import RequestPayloadBuilder
 
@@ -367,3 +370,133 @@ def test_build_plot_data(self):
         assert plot_data["label"] == plot_value["label"]
         assert plot_data["line_colour"] == plot_value["line_colour"]
         assert plot_data["line_type"] == plot_value["line_type"]
+
+    @pytest.mark.parametrize(
+        "chart_is_double_width, expected_chart_width", ([(True, 1100), (False, 515)])
+    )
+    def test_build_dual_category_chart_request_data(
+        self,
+        chart_is_double_width: bool,
+        expected_chart_width: int,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+    ):
+        """
+        Given a dual category chart block
+        When `build_dual_category_chart_request_data()` is called
+            from an instance of `RequestPayloadBuilder`
+        Then the correct dict is returned
+        """
+        # Given
+        chart_block_data = example_dual_category_chart_block
+        request_payload_builder = RequestPayloadBuilder()
+
+        # When
+        chart_request_data = (
+            request_payload_builder.build_dual_category_chart_request_data(
+                chart_block=chart_block_data,
+                chart_is_double_width=chart_is_double_width,
+            )
+        )
+
+        # Then
+        base_request_data = request_payload_builder.base_dual_category_request_data(
+            chart_block_data
+        )
+        expected_chart_request_data = {
+            **base_request_data,
+            "file_format": "svg",
+            "chart_height": 260,
+            "chart_width": expected_chart_width,
+            "x_axis_title": chart_block_data.get("x_axis_title", ""),
+            "y_axis_title": chart_block_data.get("y_axis_title", ""),
+            "y_axis_minimum_value": chart_block_data.get("y_axis_minimum_value", None),
+            "y_axis_maximum_value": chart_block_data.get("y_axis_maximum_value", None),
+            "chart_type": chart_block_data["chart_type"],
+            "legend_title": chart_block_data["title"],
+        }
+        assert chart_request_data == expected_chart_request_data
+
+    def test_build_dual_category_tables_request_data(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+    ):
+        """
+        Given a dual category chart block
+        When `build_dual_category_tables_request_data()` is called
+            from an instance of `RequestPayloadBuilder`
+        Then the correct dict is returned
+        """
+        # Given
+        chart_block_data = example_dual_category_chart_block
+        request_payload_builder = RequestPayloadBuilder()
+
+        # When
+        tables_request_data = (
+            request_payload_builder.build_dual_category_tables_request_data(
+                chart_block=chart_block_data
+            )
+        )
+
+        # Then
+        expected_tables_request_data = (
+            request_payload_builder.base_dual_category_request_data(chart_block_data)
+        )
+        assert tables_request_data == expected_tables_request_data
+
+    def test_build_dual_category_downloads_request_data(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+    ):
+        """
+        Given a dual category chart block
+        When `build_dual_category_downloads_request_data()` is called
+            from an instance of `RequestPayloadBuilder`
+        Then the correct dict is returned
+        """
+        # Given
+        chart_block_data = example_dual_category_chart_block
+        file_format = "csv"
+        request_payload_builder = RequestPayloadBuilder()
+
+        # When
+        downloads_request_data = (
+            request_payload_builder.build_dual_category_downloads_request_data(
+                chart_block=chart_block_data, file_format=file_format
+            )
+        )
+
+        # Then
+        base_request_data = request_payload_builder.base_dual_category_request_data(
+            chart_block_data
+        )
+        expected_downloads_request_data = {
+            **base_request_data,
+            "file_format": file_format,
+        }
+        assert downloads_request_data == expected_downloads_request_data
+
+    def test_base_dual_category_request_data_defaults_date_to_when_none(
+        self,
+        example_dual_category_chart_block: dict[str, str | list[dict]],
+    ):
+        """
+        Given a dual category chart block with no `date_to` in static fields
+        When `base_dual_category_request_data()` is called from `RequestPayloadBuilder`
+        Then today's date is applied to `date_to`
+        """
+        # Given
+        chart_block_data = deepcopy(example_dual_category_chart_block)
+        chart_block_data["static_fields"] = chart_block_data["static_fields"].copy()
+        chart_block_data["static_fields"]["date_to"] = None
+
+        # When
+        with mock.patch(
+            "caching.private_api.crawler.request_payload_builder.datetime"
+        ) as mock_datetime:
+            mock_datetime.now.return_value = datetime(2026, 6, 26)
+            request_data = RequestPayloadBuilder.base_dual_category_request_data(
+                chart_block_data
+            )
+
+        # Then
+        assert request_data["static_fields"]["date_to"] == "2026-06-26"