qontract-reconcile 0.10.1rc763__py3-none-any.whl → 0.10.1rc765__py3-none-any.whl

reconcile/external_resources/state.py

@@ -0,0 +1,246 @@
+import logging
+from collections.abc import Mapping
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+
+import boto3
+from pydantic import BaseModel
+
+from reconcile.external_resources.model import (
+    ExternalResourceKey,
+    ExternalResourceModuleConfiguration,
+    Reconciliation,
+)
+
+DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+
+class StateNotFoundError(Exception):
+    pass
+
+
+class ReconcileStatus(str, Enum):
+    SUCCESS: str = "SUCCESS"
+    ERROR: str = "ERROR"
+    IN_PROGRESS: str = "IN_PROGRESS"
+    NOT_EXISTS: str = "NOT_EXISTS"
+
+
+class ResourceStatus(str, Enum):
+    CREATED: str = "CREATED"
+    DELETED: str = "DELETED"
+    ABANDONED: str = "ABANDONED"
+    NOT_EXISTS: str = "NOT_EXISTS"
+    IN_PROGRESS: str = "IN_PROGRESS"
+    DELETE_IN_PROGRESS: str = "DELETE_IN_PROGRESS"
+    ERROR: str = "ERROR"
+
+
+class ExternalResourceState(BaseModel):
+    key: ExternalResourceKey
+    ts: datetime
+    resource_status: ResourceStatus
+    reconciliation: Reconciliation
+    reconciliation_errors: int = 0
+
+
+class DynamoDBStateAdapter:
+    # Table PK
+    ER_KEY_HASH = "external_resource_key_hash"
+
+    RESOURCE_STATUS = "resource_status"
+    TIMESTAMP = "time_stamp"
+    RECONCILIATION_ERRORS = "reconciliation_errors"
+
+    ER_KEY = "external_resource_key"
+    ER_KEY_PROVISION_PROVIDER = "provision_provider"
+    ER_KEY_PROVISIONER_NAME = "provisioner_name"
+    ER_KEY_PROVIDER = "provider"
+    ER_KEY_IDENTIFIER = "identifier"
+
+    RECONC = "reconciliation"
+    RECONC_RESOURCE_HASH = "resource_hash"
+    RECONC_INPUT = "input"
+    RECONC_ACTION = "action"
+
+    MODCONF = "module_configuration"
+    MODCONF_IMAGE = "image"
+    MODCONF_VERSION = "version"
+    MODCONF_DRIFT_MINS = "drift_detection_minutes"
+    MODCONF_TIMEOUT_MINS = "timeout_minutes"
+
+    def _get_value(self, item: Mapping[str, Any], key: str, _type: str = "S") -> Any:
+        return item[key][_type]
+
+    def deserialize(
+        self, item: Mapping[str, Any], partial_data: bool = False
+    ) -> ExternalResourceState:
+        _key = self._get_value(item, self.ER_KEY, _type="M")
+        key = ExternalResourceKey(
+            provision_provider=self._get_value(_key, self.ER_KEY_PROVISION_PROVIDER),
+            provisioner_name=self._get_value(_key, self.ER_KEY_PROVISIONER_NAME),
+            provider=self._get_value(_key, self.ER_KEY_PROVIDER),
+            identifier=self._get_value(_key, self.ER_KEY_IDENTIFIER),
+        )
+        _reconciliation = self._get_value(item, self.RECONC, _type="M")
+
+        if partial_data:
+            r = Reconciliation(
+                key=key,
+                resource_hash=self._get_value(
+                    _reconciliation, self.RECONC_RESOURCE_HASH
+                ),
+            )
+        else:
+            _modconf = self._get_value(_reconciliation, self.MODCONF, _type="M")
+            r = Reconciliation(
+                key=key,
+                resource_hash=self._get_value(
+                    _reconciliation, self.RECONC_RESOURCE_HASH
+                ),
+                input=self._get_value(_reconciliation, self.RECONC_INPUT),
+                action=self._get_value(_reconciliation, self.RECONC_ACTION),
+                module_configuration=ExternalResourceModuleConfiguration(
+                    image=self._get_value(_modconf, self.MODCONF_IMAGE),
+                    version=self._get_value(_modconf, self.MODCONF_VERSION),
+                    reconcile_drift_interval_minutes=self._get_value(
+                        _modconf, self.MODCONF_DRIFT_MINS, _type="N"
+                    ),
+                    reconcile_timeout_minutes=self._get_value(
+                        _modconf, self.MODCONF_TIMEOUT_MINS, _type="N"
+                    ),
+                ),
+            )
+
+        return ExternalResourceState(
+            key=key,
+            ts=self._get_value(item, self.TIMESTAMP),
+            resource_status=self._get_value(item, self.RESOURCE_STATUS),
+            reconciliation=r,
+            reconciliation_errors=int(
+                self._get_value(item, self.RECONCILIATION_ERRORS, _type="N")
+            ),
+        )
+
+    def serialize(self, state: ExternalResourceState) -> dict[str, Any]:
+        return {
+            self.ER_KEY_HASH: {"S": state.key.hash()},
+            self.TIMESTAMP: {"S": state.ts.isoformat()},
+            self.RESOURCE_STATUS: {"S": state.resource_status.value},
+            self.RECONCILIATION_ERRORS: {"N": str(state.reconciliation_errors)},
+            self.ER_KEY: {
+                "M": {
+                    self.ER_KEY_PROVISION_PROVIDER: {"S": state.key.provision_provider},
+                    self.ER_KEY_PROVISIONER_NAME: {"S": state.key.provisioner_name},
+                    self.ER_KEY_PROVIDER: {"S": state.key.provider},
+                    self.ER_KEY_IDENTIFIER: {"S": state.key.identifier},
+                }
+            },
+            self.RECONC: {
+                "M": {
+                    self.RECONC_RESOURCE_HASH: {
+                        "S": state.reconciliation.resource_hash
+                    },
+                    self.RECONC_ACTION: {"S": state.reconciliation.action.value},
+                    self.RECONC_INPUT: {"S": state.reconciliation.input},
+                    self.MODCONF: {
+                        "M": {
+                            self.MODCONF_IMAGE: {
+                                "S": state.reconciliation.module_configuration.image
+                            },
+                            self.MODCONF_VERSION: {
+                                "S": state.reconciliation.module_configuration.version
+                            },
+                            self.MODCONF_DRIFT_MINS: {
+                                "N": str(
+                                    state.reconciliation.module_configuration.reconcile_drift_interval_minutes
+                                )
+                            },
+                            self.MODCONF_TIMEOUT_MINS: {
+                                "N": str(
+                                    state.reconciliation.module_configuration.reconcile_timeout_minutes
+                                )
+                            },
+                        }
+                    },
+                }
+            },
+        }
+
+
+class ExternalResourcesStateDynamoDB:
+    PARTIALS_PROJECTED_VALUES = ",".join([
+        DynamoDBStateAdapter.ER_KEY,
+        DynamoDBStateAdapter.TIMESTAMP,
+        DynamoDBStateAdapter.RESOURCE_STATUS,
+        DynamoDBStateAdapter.RECONCILIATION_ERRORS,
+        f"{DynamoDBStateAdapter.RECONC}.{DynamoDBStateAdapter.RECONC_RESOURCE_HASH}",
+    ])
+
+    def __init__(self, table_name: str, region_name: str) -> None:
+        self.adapter = DynamoDBStateAdapter()
+        self.client = boto3.client("dynamodb", region_name=region_name)
+        self._table = table_name
+        self.partial_resources = self._get_partial_resources()
+
+    def get_external_resource_state(
+        self, key: ExternalResourceKey
+    ) -> ExternalResourceState:
+        data = self.client.get_item(
+            TableName=self._table,
+            ConsistentRead=True,
+            Key={self.adapter.ER_KEY_HASH: {"S": key.hash()}},
+        )
+        if "Item" in data:
+            return self.adapter.deserialize(data["Item"])
+        else:
+            return ExternalResourceState(
+                key=key,
+                ts=datetime.now(timezone.utc),
+                resource_status=ResourceStatus.NOT_EXISTS,
+                reconciliation=Reconciliation(key=key),
+                reconciliation_errors=0,
+            )
+
+    def set_external_resource_state(
+        self,
+        state: ExternalResourceState,
+    ) -> None:
+        self.client.put_item(TableName=self._table, Item=self.adapter.serialize(state))
+
+    def del_external_resource_state(self, key: ExternalResourceKey) -> None:
+        self.client.delete_item(
+            TableName=self._table,
+            Key={self.adapter.ER_KEY_HASH: {"S": key.hash()}},
+        )
+
+    def _get_partial_resources(
+        self,
+    ) -> dict[ExternalResourceKey, ExternalResourceState]:
+        """A Partial Resoure is the minimum resource data reguired
+        to check if a resource has been removed from the configuration.
+        Getting less data from DynamoDb saves money and the logic does not need it.
+        """
+        logging.info("Getting Managed resources from DynamoDb")
+        partials = {}
+        for item in self.client.scan(
+            TableName=self._table, ProjectionExpression=self.PARTIALS_PROJECTED_VALUES
+        ).get("Items", []):
+            s = self.adapter.deserialize(item, partial_data=True)
+            partials[s.key] = s
+        return partials
+
+    def get_all_resource_keys(self) -> set[ExternalResourceKey]:
+        return {k for k in self.partial_resources.keys()}
+
+    def update_resource_status(
+        self, key: ExternalResourceKey, status: ResourceStatus
+    ) -> None:
+        self.client.update_item(
+            TableName=self._table,
+            Key={self.adapter.ER_KEY_HASH: {"S": key.hash()}},
+            UpdateExpression="set resource_status=:new_value",
+            ExpressionAttributeValues={":new_value": {"S": status.value}},
+            ReturnValues="UPDATED_NEW",
+        )

reconcile/saas_auto_promotions_manager/meta.py

@@ -1,4 +1,4 @@
 from reconcile.utils.semver_helper import make_semver
 
 QONTRACT_INTEGRATION = "saas-auto-promotions-manager"
-QONTRACT_INTEGRATION_VERSION = make_semver(2, 1, 4)
+QONTRACT_INTEGRATION_VERSION = make_semver(2, 2, 0)

reconcile/saas_auto_promotions_manager/subscriber.py

@@ -1,8 +1,8 @@
 import hashlib
 import logging
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any, Optional
 
 from reconcile.gql_definitions.fragments.saas_target_namespace import (
     SaasTargetNamespace,
@@ -42,6 +42,7 @@ class Subscriber:
         target_file_path: str,
         target_namespace: SaasTargetNamespace,
         use_target_config_hash: bool,
+        uid: str,
     ):
         self.saas_name = saas_name
         self.template_name = template_name
@@ -52,6 +53,7 @@ class Subscriber:
         self.desired_ref = ""
         self.desired_hashes: list[ConfigHash] = []
         self.target_namespace = target_namespace
+        self.uid = uid
         self._content_hash = ""
         self._use_target_config_hash = use_target_config_hash
 
@@ -73,6 +75,54 @@ class Subscriber:
         self._compute_desired_ref()
         self._compute_desired_config_hashes()
 
+    @staticmethod
+    def from_exported_dict(data: Mapping[str, Any]) -> "Subscriber":
+        subscriber = Subscriber(
+            saas_name=data["1"],
+            template_name=data["2"],
+            ref=data["3"],
+            target_file_path=data["4"],
+            use_target_config_hash=data["5"],
+            target_namespace=SaasTargetNamespace(**data["6"]),
+            uid=data["7"],
+        )
+        subscriber.desired_hashes = data["8"]
+        subscriber.desired_ref = data["9"]
+        return subscriber
+
+    def to_exportable_dict(self) -> dict[str, Any]:
+        """
+        We will later persist subscriber data as json in MRs. We keep key size small to use less space.
+        Note, the data will be encoded and encrypted in another component.
+        """
+        data: dict[str, Any] = {}
+        data["1"] = self.saas_name
+        data["2"] = self.template_name
+        data["3"] = self.ref
+        data["4"] = self.target_file_path
+        data["5"] = self._use_target_config_hash
+        data["6"] = self.target_namespace.dict(by_alias=True)
+        data["7"] = self.uid
+        data["8"] = self.desired_hashes
+        data["9"] = self.desired_ref
+        return data
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Subscriber):
+            # don't attempt to compare against unrelated types
+            return False
+        return (
+            self.saas_name == other.saas_name
+            and self.template_name == other.template_name
+            and self.ref == other.ref
+            and self.target_file_path == other.target_file_path
+            and self._use_target_config_hash == other._use_target_config_hash
+            and self.desired_ref == other.desired_ref
+            and self.desired_hashes == other.desired_hashes
+            and self.target_namespace == other.target_namespace
+            and self.uid == other.uid
+        )
+
     def _validate_deployment(
         self, publisher: Publisher, channel: Channel
     ) -> Optional[DeploymentInfo]:

reconcile/saas_auto_promotions_manager/utils/saas_files_inventory.py

@@ -92,6 +92,10 @@ class SaasFilesInventory:
                     if not target.promotion.auto:
                         continue
                     subscriber = Subscriber(
+                        uid=target.uid(
+                            parent_saas_file_name=saas_file.name,
+                            parent_resource_template_name=resource_template.name,
+                        ),
                         saas_name=saas_file.name,
                         template_name=resource_template.name,
                         target_file_path=file_path,

reconcile/test/saas_auto_promotions_manager/conftest.py

@@ -1,9 +1,11 @@
+from collections import defaultdict
 from collections.abc import (
     Callable,
     Iterable,
     Mapping,
     MutableMapping,
 )
+from typing import Any
 from unittest.mock import (
     MagicMock,
     create_autospec,
@@ -14,6 +16,12 @@ import pytest
 from reconcile.gql_definitions.fragments.saas_target_namespace import (
     SaasTargetNamespace,
 )
+from reconcile.saas_auto_promotions_manager.publisher import DeploymentInfo, Publisher
+from reconcile.saas_auto_promotions_manager.subscriber import (
+    Channel,
+    ConfigHash,
+    Subscriber,
+)
 from reconcile.typed_queries.saas_files import SaasFile
 from reconcile.utils.gitlab_api import GitLabApi
 from reconcile.utils.promotion_state import (
@@ -100,3 +108,58 @@ def promotion_state_builder() -> Callable[..., PromotionState]:
         return promotion_state
 
     return builder
+
+
+@pytest.fixture
+def subscriber_builder(
+    saas_target_namespace_builder: Callable[..., SaasTargetNamespace],
+) -> Callable[[Mapping[str, Any]], Subscriber]:
+    def builder(data: Mapping[str, Any]) -> Subscriber:
+        channels: list[Channel] = []
+        for channel_name, channel_data in data.get("CHANNELS", {}).items():
+            channel = Channel(name=channel_name, publishers=[])
+            for publisher_name, publisher_data in channel_data.items():
+                publisher = Publisher(
+                    ref="",
+                    uid="",
+                    repo_url="",
+                    cluster_name="",
+                    namespace_name="",
+                    saas_name="",
+                    saas_file_path="",
+                    app_name="",
+                    resource_template_name="",
+                    target_name=None,
+                    publish_job_logs=True,
+                    has_subscriber=True,
+                    auth_code=None,
+                )
+                publisher.commit_sha = publisher_data["REAL_WORLD_SHA"]
+                publisher.deployment_info_by_channel[channel_name] = DeploymentInfo(
+                    success=publisher_data.get("SUCCESSFUL_DEPLOYMENT", True),
+                    target_config_hash=publisher_data.get("CONFIG_HASH", ""),
+                    saas_file=publisher_name,
+                )
+                channel.publishers.append(publisher)
+            channels.append(channel)
+        cur_config_hashes_by_channel: dict[str, list[ConfigHash]] = defaultdict(list)
+        for cur_config_hash in data.get("CUR_CONFIG_HASHES", []):
+            cur_config_hashes_by_channel[cur_config_hash.channel].append(
+                cur_config_hash
+            )
+        subscriber = Subscriber(
+            uid=data.get("SUB_UID", "default"),
+            target_namespace=saas_target_namespace_builder(data.get("NAMESPACE", {})),
+            ref=data.get("CUR_SUBSCRIBER_REF", ""),
+            saas_name="",
+            target_file_path=data.get("TARGET_FILE_PATH", ""),
+            template_name="",
+            use_target_config_hash=data.get("USE_TARGET_CONFIG_HASH", True),
+        )
+        subscriber.channels = channels
+        subscriber.config_hashes_by_channel_name = cur_config_hashes_by_channel
+        subscriber.desired_ref = data.get("DESIRED_REF", "")
+        subscriber.desired_hashes = data.get("DESIRED_TARGET_HASHES", [])
+        return subscriber
+
+    return builder

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/conftest.py

@@ -8,9 +8,6 @@ from unittest.mock import create_autospec
 import pytest
 from gitlab.v4.objects import ProjectMergeRequest
 
-from reconcile.gql_definitions.fragments.saas_target_namespace import (
-    SaasTargetNamespace,
-)
 from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager_v2 import (
     SAPM_LABEL,
 )
@@ -31,24 +28,17 @@ from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer impor
     VERSION_REF,
     Renderer,
 )
-from reconcile.saas_auto_promotions_manager.subscriber import (
-    Channel,
-    Subscriber,
-)
 from reconcile.utils.vcs import VCS, MRCheckStatus
 
 from .data_keys import (
-    CHANNEL,
     DESCRIPTION,
     HAS_CONFLICTS,
     LABELS,
     OPEN_MERGE_REQUESTS,
     PIPELINE_RESULTS,
-    REF,
     SUBSCRIBER_BATCHABLE,
     SUBSCRIBER_CHANNELS,
     SUBSCRIBER_CONTENT_HASH,
-    SUBSCRIBER_TARGET_PATH,
 )
 
 
@@ -120,33 +110,6 @@ def reconciler_builder() -> Callable[[Diff], Reconciler]:
     return builder
 
 
-@pytest.fixture
-def subscriber_builder(
-    saas_target_namespace_builder: Callable[..., SaasTargetNamespace],
-) -> Callable[..., Subscriber]:
-    def builder(data: Mapping) -> Subscriber:
-        subscriber = Subscriber(
-            saas_name="",
-            template_name="",
-            target_namespace=saas_target_namespace_builder({}),
-            ref="",
-            target_file_path=data.get(SUBSCRIBER_TARGET_PATH, ""),
-            use_target_config_hash=True,
-        )
-        subscriber.desired_hashes = []
-        subscriber.desired_ref = data.get(REF, "")
-        for channel in data.get(CHANNEL, []):
-            subscriber.channels.append(
-                Channel(
-                    name=channel,
-                    publishers=[],
-                )
-            )
-        return subscriber
-
-    return builder
-
-
 @pytest.fixture
 def renderer() -> Renderer:
     return create_autospec(spec=Renderer)

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/test_desired_state.py

@@ -5,10 +5,6 @@ from reconcile.saas_auto_promotions_manager.merge_request_manager.desired_state
 )
 from reconcile.saas_auto_promotions_manager.subscriber import Subscriber
 
-from .data_keys import (
-    CHANNEL,
-)
-
 
 def test_desired_state_empty() -> None:
     desired_state = DesiredState(subscribers=[])
@@ -29,10 +25,14 @@ def test_desired_state_single_subscriber(
 def test_desired_state_multiple_subscribers_same_channel_combo(
     subscriber_builder: Callable[..., Subscriber],
 ) -> None:
-    subscriber_a = subscriber_builder({CHANNEL: ["channel-a", "channel-b"]})
-    subscriber_a.desired_ref = "ref-a"
-    subscriber_b = subscriber_builder({CHANNEL: ["channel-a", "channel-b"]})
-    subscriber_b.desired_ref = "ref-b"
+    subscriber_a = subscriber_builder({
+        "CHANNELS": {"channel-a": {}, "channel-b": {}},
+        "DESIRED_REF": "ref-a",
+    })
+    subscriber_b = subscriber_builder({
+        "CHANNELS": {"channel-a": {}, "channel-b": {}},
+        "DESIRED_REF": "ref-b",
+    })
     desired_state = DesiredState(subscribers=[subscriber_a, subscriber_b])
     assert len(desired_state.promotions) == 1
     assert desired_state.promotions[0].content_hashes == {
@@ -43,12 +43,18 @@ def test_desired_state_multiple_subscribers_same_channel_combo(
 def test_desired_state_multiple_subscribers_different_channel_combo(
     subscriber_builder: Callable[..., Subscriber],
 ) -> None:
-    subscriber_a = subscriber_builder({CHANNEL: ["channel-a", "channel-b"]})
-    subscriber_a.desired_ref = "ref-a"
-    subscriber_b = subscriber_builder({CHANNEL: ["channel-a", "channel-b"]})
-    subscriber_b.desired_ref = "ref-b"
-    subscriber_c = subscriber_builder({CHANNEL: ["channel-b", "channel-c"]})
-    subscriber_c.desired_ref = "ref-c"
+    subscriber_a = subscriber_builder({
+        "CHANNELS": {"channel-a": {}, "channel-b": {}},
+        "DESIRED_REF": "ref-a",
+    })
+    subscriber_b = subscriber_builder({
+        "CHANNELS": {"channel-a": {}, "channel-b": {}},
+        "DESIRED_REF": "ref-b",
+    })
+    subscriber_c = subscriber_builder({
+        "CHANNELS": {"channel-b": {}, "channel-c": {}},
+        "DESIRED_REF": "ref-c",
+    })
     desired_state = DesiredState(subscribers=[subscriber_a, subscriber_b, subscriber_c])
     sorted_promotions = sorted(desired_state.promotions)
     assert len(desired_state.promotions) == 2

reconcile/test/saas_auto_promotions_manager/merge_request_manager/renderer/conftest.py

@@ -1,26 +1,10 @@
 import os
 from collections.abc import (
     Callable,
-    Mapping,
 )
 
 import pytest
 
-from reconcile.gql_definitions.fragments.saas_target_namespace import (
-    SaasTargetNamespace,
-)
-from reconcile.saas_auto_promotions_manager.subscriber import (
-    Channel,
-    Subscriber,
-)
-
-from .data_keys import (
-    CHANNELS,
-    CONFIG_HASHES,
-    NAMESPACE,
-    REF,
-)
-
 
 @pytest.fixture
 def file_contents() -> Callable[[str], tuple[str, str]]:
@@ -39,30 +23,3 @@ def file_contents() -> Callable[[str], tuple[str, str]]:
         return (a, b)
 
     return contents
-
-
-@pytest.fixture
-def subscriber_builder(
-    saas_target_namespace_builder: Callable[..., SaasTargetNamespace],
-) -> Callable[[Mapping], Subscriber]:
-    def builder(data: Mapping) -> Subscriber:
-        subscriber = Subscriber(
-            target_namespace=saas_target_namespace_builder(data.get(NAMESPACE, {})),
-            ref="",
-            saas_name="",
-            target_file_path="",
-            template_name="",
-            use_target_config_hash=True,
-        )
-        subscriber.desired_ref = data[REF]
-        subscriber.desired_hashes = data[CONFIG_HASHES]
-        for channel in data.get(CHANNELS, []):
-            subscriber.channels.append(
-                Channel(
-                    name=channel,
-                    publishers=[],
-                )
-            )
-        return subscriber
-
-    return builder

reconcile/test/saas_auto_promotions_manager/merge_request_manager/renderer/test_content_multiple_namespaces.py

@@ -11,29 +11,22 @@ from reconcile.saas_auto_promotions_manager.subscriber import (
     Subscriber,
 )
 
-from .data_keys import (
-    CHANNELS,
-    CONFIG_HASHES,
-    NAMESPACE,
-    REF,
-)
-
 
 def test_content_multiple_namespaces(
     file_contents: Callable[[str], tuple[str, str]],
     subscriber_builder: Callable[[Mapping], Subscriber],
 ):
     subscriber = subscriber_builder({
-        NAMESPACE: {"path": "/some/namespace.yml"},
-        REF: "new_sha",
-        CONFIG_HASHES: [
+        "NAMESPACE": {"path": "/some/namespace.yml"},
+        "DESIRED_REF": "new_sha",
+        "DESIRED_TARGET_HASHES": [
             ConfigHash(
                 channel="channel-a",
                 target_config_hash="new_hash",
                 parent_saas="parent_saas",
             )
         ],
-        CHANNELS: ["channel-a"],
+        "CHANNELS": {"channel-a": {}},
     })
     saas_content, expected = file_contents("multiple_namespaces")
     renderer = Renderer()