More progress

Author: lgarber-akamai

linode_api4/linode_client.py

@@ -455,7 +455,13 @@ def volume_create(self, label, region=None, linode=None, size=20, **kwargs):
         )
 
     # helper functions
-    def _get_and_filter(self, obj_type, *filters, endpoint=None):
+    def _get_and_filter(
+        self,
+        obj_type,
+        *filters,
+        endpoint=None,
+        parent_id=None,
+    ):
         parsed_filters = None
         if filters:
             if len(filters) > 1:
@@ -467,8 +473,13 @@ def _get_and_filter(self, obj_type, *filters, endpoint=None):
 
         # Use sepcified endpoint
         if endpoint:
-            return self._get_objects(endpoint, obj_type, filters=parsed_filters)
+            return self._get_objects(
+                endpoint, obj_type, parent_id=parent_id, filters=parsed_filters
+            )
         else:
             return self._get_objects(
-                obj_type.api_list(), obj_type, filters=parsed_filters
+                obj_type.api_list(),
+                obj_type,
+                parent_id=parent_id,
+                filters=parsed_filters,
             )

linode_api4/objects/lke.py

@@ -195,6 +195,9 @@ class LKENodePool(DerivedBase):
         "labels": Property(mutable=True),
         "taints": Property(mutable=True),
         # Enterprise-specific properties
+        # Ideally we would use slug_relationship=TieredKubeVersion here, but
+        # it isn't possible without an extra request because the tier is not
+        # directly exposed in the node pool response.
         "k8s_version": Property(mutable=True),
         "update_strategy": Property(mutable=True),
     }

linode_api4/paths/lke.py

@@ -36,5 +36,6 @@ def versions(self, *filters):
         return self.client._get_and_filter(
             TieredKubeVersion,
             endpoint=f"{self.endpoint}/versions",
+            parent_id=self.id,
             *filters,
         )

test/integration/models/lke/test_lke.py

@@ -14,6 +14,7 @@
     LKEClusterControlPlaneACLAddressesOptions,
     LKEClusterControlPlaneACLOptions,
     LKEClusterControlPlaneOptions,
+    TieredKubeVersion,
 )
 from linode_api4.common import RegionPrice
 from linode_api4.errors import ApiError
@@ -136,6 +137,35 @@ def lke_cluster_with_apl(test_linode_client):
     cluster.delete()
 
 
+@pytest.fixture(scope="session")
+def lke_cluster_enterprise(test_linode_client):
+    version = test_linode_client.lke.tier("enterprise").versions()[0]
+
+    region = get_region(
+        test_linode_client, {"Kubernetes Enterprise", "Disk Encryption"}
+    )
+
+    node_pools = test_linode_client.lke.node_pool(
+        "g6-dedicated-2",
+        3,
+        k8s_version=version.id,
+        update_strategy="rolling_update",
+    )
+    label = get_test_label() + "_cluster"
+
+    cluster = test_linode_client.lke.cluster_create(
+        region,
+        label,
+        node_pools,
+        version.id,
+        tier="enterprise",
+    )
+
+    yield cluster
+
+    cluster.delete()
+
+
 def get_cluster_status(cluster: LKECluster, status: str):
     return cluster._raw_json["status"] == status
 
@@ -398,6 +428,42 @@ def test_lke_cluster_with_apl(lke_cluster_with_apl):
     )
 
 
+def test_lke_cluster_enterprise(lke_cluster_enterprise):
+    lke_cluster_enterprise.invalidate()
+    assert lke_cluster_enterprise.tier == "enterprise"
+
+    pool = lke_cluster_enterprise.pools[0]
+    assert str(pool.k8s_version) == lke_cluster_enterprise.k8s_version.id
+    assert pool.update_strategy == "rolling_update"
+
+    pool.update_strategy = "on_delete"
+    pool.k8s_version = ""
+
+
+def test_lke_tiered_versions(test_linode_client):
+    def __assert_version(tier: str, version: TieredKubeVersion):
+        assert version.tier == tier
+        assert len(version.id) > 0
+
+    standard_versions = test_linode_client.lke.tier("standard").versions()
+    assert len(standard_versions) > 0
+
+    standard_version = standard_versions[0]
+    __assert_version("standard", standard_version)
+
+    standard_version.invalidate()
+    __assert_version("standard", standard_version)
+
+    enterprise_versions = test_linode_client.lke.tier("enterprise").versions()
+    assert len(enterprise_versions) > 0
+
+    enterprise_version = enterprise_versions[0]
+    __assert_version("enterprise", enterprise_version)
+
+    enterprise_version.invalidate()
+    __assert_version("enterprise", enterprise_version)
+
+
 def test_lke_types(test_linode_client):
     types = test_linode_client.lke.types()