Add LocalDNS Live Tests for valid and invalid scenarios

src/aks-preview/HISTORY.rst

@@ -12,6 +12,12 @@ To release a new version, please select a new version number (usually plus 1 to
 Pending
 +++++++
 
+18.0.0b43
++++++++
+* Fix `--localdns-config` parameter to handle null values and case-insensitive JSON keys in DNS override sections, preventing crashes with malformed localdns configuration files.
+* Enhance `build_override` function to validate dictionary types and only initialize DNS overrides when present in localdns configuration (case-insensitive).
+* Refactor `build_localdns_profile` function to eliminate code duplication between AgentPool add and update operations.
+
 18.0.0b42
 +++++++
 * Fix role assignment failure when using azure-cli version >= `2.77.0`.

src/aks-preview/azext_aks_preview/_helpers.py

@@ -460,6 +460,10 @@ def process_dns_overrides(overrides_dict, target_dict, build_override_func):
     :param target_dict: Target dictionary to populate with processed overrides
     :param build_override_func: Function to build override objects from dict values
     """
+    if not isinstance(overrides_dict, dict):
+        raise InvalidArgumentValueError(
+            f"Expected a dictionary for DNS overrides, but got {type(overrides_dict).__name__}: {overrides_dict}"
+        )
     if overrides_dict is not None:
         for key, value in overrides_dict.items():
             if value is not None:

src/aks-preview/azext_aks_preview/agentpool_decorator.py

@@ -940,6 +940,78 @@ def get_localdns_profile(self):
             return profile
         return None
 
+    def build_localdns_profile(self, agentpool: AgentPool) -> AgentPool:
+        """Build local DNS profile for the AgentPool object if provided via --localdns-config."""
+        localdns_profile = self.get_localdns_profile()
+        kube_dns_overrides, vnet_dns_overrides = None, None
+
+        if localdns_profile is not None:
+            def find_keys_case_insensitive(dictionary, target_keys):
+                """Find multiple keys case-insensitively and return a dict mapping target_key -> actual_key"""
+                result = {}
+                lowered_keys = {key.lower(): key for key in dictionary.keys()}
+                for target_key in target_keys:
+                    lowered_target = target_key.lower()
+                    if lowered_target in lowered_keys:
+                        result[target_key] = lowered_keys[lowered_target]
+                    else:
+                        result[target_key] = None
+                return result
+
+            def build_override(override_dict):
+                if not isinstance(override_dict, dict):
+                    raise InvalidArgumentValueError(
+                        f"Expected a dictionary for DNS override settings,"
+                        f" but got {type(override_dict).__name__}: {override_dict}"
+                    )
+                camel_to_snake_case = {
+                    "queryLogging": "query_logging",
+                    "protocol": "protocol",
+                    "forwardDestination": "forward_destination",
+                    "forwardPolicy": "forward_policy",
+                    "maxConcurrent": "max_concurrent",
+                    "cacheDurationInSeconds": "cache_duration_in_seconds",
+                    "serveStaleDurationInSeconds": "serve_stale_duration_in_seconds",
+                    "serveStale": "serve_stale",
+                }
+                valid_keys = set(camel_to_snake_case.values())
+                filtered = {}
+                for k, v in override_dict.items():
+                    if k in camel_to_snake_case:
+                        filtered[camel_to_snake_case[k]] = v
+                    elif k in valid_keys:
+                        filtered[k] = v
+                return self.models.LocalDNSOverride(**filtered)
+
+            # Build kubeDNSOverrides and vnetDNSOverrides from the localdns_profile
+            key_mappings = find_keys_case_insensitive(localdns_profile, ["kubeDNSOverrides", "vnetDNSOverrides"])
+            actual_kube_key = key_mappings["kubeDNSOverrides"]
+            if actual_kube_key:
+                logger.debug("Found kubeDNSOverrides key as: %s", actual_kube_key)
+                kube_dns_overrides = {}
+                process_dns_overrides(
+                    localdns_profile.get(actual_kube_key),
+                    kube_dns_overrides,
+                    build_override
+                )
+
+            actual_vnet_key = key_mappings["vnetDNSOverrides"]
+            if actual_vnet_key:
+                logger.debug("Found vnetDNSOverrides key as: %s", actual_vnet_key)
+                vnet_dns_overrides = {}
+                process_dns_overrides(
+                    localdns_profile.get(actual_vnet_key),
+                    vnet_dns_overrides,
+                    build_override
+                )
+
+            agentpool.local_dns_profile = self.models.LocalDNSProfile(
+                mode=localdns_profile.get("mode"),
+                kube_dns_overrides=kube_dns_overrides,
+                vnet_dns_overrides=vnet_dns_overrides,
+            )
+        return agentpool
+
     def get_node_count_and_enable_cluster_autoscaler_min_max_count_vms(
         self,
     ) -> Tuple[int, bool, Union[int, None], Union[int, None]]:
@@ -1452,49 +1524,7 @@ def set_up_managed_system_mode(self, agentpool: AgentPool) -> AgentPool:
     def set_up_localdns_profile(self, agentpool: AgentPool) -> AgentPool:
         """Set up local DNS profile for the AgentPool object if provided via --localdns-config."""
         self._ensure_agentpool(agentpool)
-        localdns_profile = self.context.get_localdns_profile()
-        if localdns_profile is not None:
-            kube_dns_overrides = {}
-            vnet_dns_overrides = {}
-
-            def build_override(override_dict):
-                camel_to_snake_case = {
-                    "queryLogging": "query_logging",
-                    "protocol": "protocol",
-                    "forwardDestination": "forward_destination",
-                    "forwardPolicy": "forward_policy",
-                    "maxConcurrent": "max_concurrent",
-                    "cacheDurationInSeconds": "cache_duration_in_seconds",
-                    "serveStaleDurationInSeconds": "serve_stale_duration_in_seconds",
-                    "serveStale": "serve_stale",
-                }
-                valid_keys = set(camel_to_snake_case.values())
-                filtered = {}
-                for k, v in override_dict.items():
-                    if k in camel_to_snake_case:
-                        filtered[camel_to_snake_case[k]] = v
-                    elif k in valid_keys:
-                        filtered[k] = v
-                return self.models.LocalDNSOverride(**filtered)
-
-            # Build kubeDNSOverrides and vnetDNSOverrides from the localdns_profile
-            process_dns_overrides(
-                localdns_profile.get("kubeDNSOverrides"),
-                kube_dns_overrides,
-                build_override
-            )
-            process_dns_overrides(
-                localdns_profile.get("vnetDNSOverrides"),
-                vnet_dns_overrides,
-                build_override
-            )
-
-            agentpool.local_dns_profile = self.models.LocalDNSProfile(
-                mode=localdns_profile.get("mode"),
-                kube_dns_overrides=kube_dns_overrides,
-                vnet_dns_overrides=vnet_dns_overrides,
-            )
-        return agentpool
+        return self.context.build_localdns_profile(agentpool)
 
     def construct_agentpool_profile_preview(self) -> AgentPool:
         """The overall controller used to construct the preview AgentPool profile.
@@ -1794,49 +1824,7 @@ def update_fips_image(self, agentpool: AgentPool) -> AgentPool:
     def update_localdns_profile(self, agentpool: AgentPool) -> AgentPool:
         """Update local DNS profile for the AgentPool object if provided via --localdns-config."""
         self._ensure_agentpool(agentpool)
-        localdns_profile = self.context.get_localdns_profile()
-        if localdns_profile is not None:
-            kube_dns_overrides = {}
-            vnet_dns_overrides = {}
-
-            def build_override(override_dict):
-                camel_to_snake_case = {
-                    "queryLogging": "query_logging",
-                    "protocol": "protocol",
-                    "forwardDestination": "forward_destination",
-                    "forwardPolicy": "forward_policy",
-                    "maxConcurrent": "max_concurrent",
-                    "cacheDurationInSeconds": "cache_duration_in_seconds",
-                    "serveStaleDurationInSeconds": "serve_stale_duration_in_seconds",
-                    "serveStale": "serve_stale",
-                }
-                valid_keys = set(camel_to_snake_case.values())
-                filtered = {}
-                for k, v in override_dict.items():
-                    if k in camel_to_snake_case:
-                        filtered[camel_to_snake_case[k]] = v
-                    elif k in valid_keys:
-                        filtered[k] = v
-                return self.models.LocalDNSOverride(**filtered)
-
-            # Build kubeDNSOverrides and vnetDNSOverrides from the localdns_profile
-            process_dns_overrides(
-                localdns_profile.get("kubeDNSOverrides"),
-                kube_dns_overrides,
-                build_override
-            )
-            process_dns_overrides(
-                localdns_profile.get("vnetDNSOverrides"),
-                vnet_dns_overrides,
-                build_override
-            )
-
-            agentpool.local_dns_profile = self.models.LocalDNSProfile(
-                mode=localdns_profile.get("mode"),
-                kube_dns_overrides=kube_dns_overrides,
-                vnet_dns_overrides=vnet_dns_overrides,
-            )
-        return agentpool
+        return self.context.build_localdns_profile(agentpool)
 
     def update_upgrade_strategy(self, agentpool: AgentPool) -> AgentPool:
         """Update upgrade strategy for the AgentPool object.

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/disabled_mode_only.json

@@ -0,0 +1,3 @@
+{
+  "mode": "Disabled"
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/empty.json

@@ -0,0 +1 @@
+{}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/empty_mode.json

@@ -0,0 +1,3 @@
+{
+  "mode": ""
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/invalid_mode.json

@@ -0,0 +1,3 @@
+{
+  "mode": "InvalidMode"
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig.json → src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/localdnsconfig.json

@@ -1,6 +1,6 @@
 {
   "mode": "Required",
-  "kubeDNSOverrides": {
+  "kubednsoverrides": {
     ".": {
       "cacheDurationInSeconds": 3600,
       "forwardDestination": "ClusterCoreDNS",
@@ -22,7 +22,7 @@
       "serveStaleDurationInSeconds": 3600
     }
   },
-  "vnetDNSOverrides": {
+  "VNETDNSOVERRIDES": {
     ".": {
       "cacheDurationInSeconds": 3600,
       "forwardDestination": "VnetDNS",

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/localdnsconfig_with_extra_property.json

@@ -0,0 +1,48 @@
+{
+  "mode": "Required",
+  "extraProperty": "unexpected",
+  "kubeDNSOverrides": {
+    ".": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    },
+    "cluster.local": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "ForceTCP",
+      "queryLogging": "Error",
+      "serveStale": "Immediate",
+      "serveStaleDurationInSeconds": 3600
+    }
+  },
+  "vnetDNSOverrides": {
+    ".": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "VnetDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    },
+    "cluster.local": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "ForceTCP",
+      "queryLogging": "Error",
+      "serveStale": "Immediate",
+      "serveStaleDurationInSeconds": 3600
+    }
+  }
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/localdnsconfig_with_extra_property_in_dnsOverrides.json

@@ -0,0 +1,52 @@
+{
+  "mode": "Required",
+  "extraProperty": "unexpected",
+  "kubeDNSOverrides": {
+    ".": {
+      "extraProperty": "unexpected",
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    },
+    "cluster.local": {
+      "extraProperty": "unexpected",
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "ForceTCP",
+      "queryLogging": "Error",
+      "serveStale": "Immediate",
+      "serveStaleDurationInSeconds": 3600
+    }
+  },
+  "vnetDNSOverrides": {
+    ".": {
+      "extraProperty": "unexpected",
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "VnetDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    },
+    "cluster.local": {
+      "extraProperty": "unexpected",
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "ForceTCP",
+      "queryLogging": "Error",
+      "serveStale": "Immediate",
+      "serveStaleDurationInSeconds": 3600
+    }
+  }
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/missing_mode.json

@@ -0,0 +1,26 @@
+{
+  "kubeDnsOverrides": {
+    ".": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "ClusterCoreDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    }
+  },
+  "vnetDnsOverrides": {
+    ".": {
+      "cacheDurationInSeconds": 3600,
+      "forwardDestination": "VnetDNS",
+      "forwardPolicy": "Sequential",
+      "maxConcurrent": 1000,
+      "protocol": "PreferUDP",
+      "queryLogging": "Error",
+      "serveStale": "Verify",
+      "serveStaleDurationInSeconds": 3600
+    }
+  }
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/null_config.json

@@ -0,0 +1 @@
+null

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/null_mode.json

@@ -0,0 +1,3 @@
+{
+  "mode": null
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/required_mode_empty_overrides.json

@@ -0,0 +1,5 @@
+{
+  "mode": "Required",
+  "kubeDnsOverrides": {},
+  "vnetDnsOverrides": {}
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/required_mode_invalid_kubedns.json

@@ -0,0 +1,8 @@
+{
+  "mode": "Required",
+  "kubeDnsOverrides": {
+    ".": {
+      "invalidField": 123
+    }
+  }
+}

src/aks-preview/azext_aks_preview/tests/latest/data/localdnsconfig/required_mode_invalid_vnetdns.json

@@ -0,0 +1,8 @@
+{
+  "mode": "Required",
+  "vnetDnsOverrides": {
+    ".": {
+      "invalidField": 456
+    }
+  }
+}