Merge pull request #770 from linode/dev

Release v5.57.1

Author: yec-akamai

.github/workflows/release.yml

@@ -67,7 +67,7 @@ jobs:
           result-encoding: string
 
       - name: Build and push to DockerHub
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # pin@v6.15.0
+        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # pin@v6.16.0
         with:
           context: .
           file: Dockerfile

.github/workflows/remote-release-trigger.yml

@@ -66,7 +66,7 @@ jobs:
           commit_sha: ${{ steps.calculate_head_sha.outputs.commit_sha }}
 
       - name: Release
-        uses: softprops/action-gh-release@c95fe1489396fe8a9eb87c0abf8aa5b2ef267fda # pin@v2.2.1
+        uses: softprops/action-gh-release@da05d552573ad5aba039eaac05058a918a7bf631 # pin@v2.2.2
         with:
           target_commitish: 'main'
           token: ${{ steps.generate_token.outputs.token }}

linodecli/api_request.py

@@ -18,6 +18,7 @@
 from linodecli.helpers import API_CA_PATH, API_VERSION_OVERRIDE
 
 from .baked.operation import (
+    ExplicitEmptyDictValue,
     ExplicitEmptyListValue,
     ExplicitNullValue,
     OpenAPIOperation,
@@ -303,15 +304,19 @@ def _traverse_request_body(o: Any) -> Any:
             if v is None:
                 continue
 
-            # Values that are expected to be serialized as empty lists
-            # and explicit None values are converted here.
+            # Values that are expected to be serialized as empty
+            # dicts, lists, and explicit None values are converted here.
             # See: operation.py
             # NOTE: These aren't handled at the top-level of this function
             # because we don't want them filtered out in the step below.
             if isinstance(v, ExplicitEmptyListValue):
                 result[k] = []
                 continue
 
+            if isinstance(v, ExplicitEmptyDictValue):
+                result[k] = {}
+                continue
+
             if isinstance(v, ExplicitNullValue):
                 result[k] = None
                 continue

linodecli/baked/operation.py

@@ -12,7 +12,7 @@
 from collections import defaultdict
 from getpass import getpass
 from os import environ, path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 
 import openapi3.paths
@@ -48,7 +48,9 @@ def parse_boolean(value: str) -> bool:
     raise argparse.ArgumentTypeError("Expected a boolean value")
 
 
-def parse_dict(value: str) -> dict:
+def parse_dict(
+    value: str,
+) -> Union[Dict[str, Any], "ExplicitEmptyDictValue", "ExplicitEmptyListValue"]:
     """
     A helper function to decode incoming JSON data as python dicts.  This is
     intended to be passed to the `type=` kwarg for ArgumentParaser.add_argument.
@@ -57,15 +59,28 @@ def parse_dict(value: str) -> dict:
     :type value: str
 
     :returns: The dict value of the input.
-    :rtype: dict
+    :rtype: dict, ExplicitEmptyDictValue, or ExplicitEmptyListValue
     """
     if not isinstance(value, str):
         raise argparse.ArgumentTypeError("Expected a JSON string")
+
     try:
-        return json.loads(value)
+        result = json.loads(value)
     except Exception as e:
         raise argparse.ArgumentTypeError("Expected a JSON string") from e
 
+    # This is necessary because empty dicts and lists are excluded from requests
+    # by default, but we still want to support user-defined empty dict
+    # strings. This is particularly helpful when updating LKE node pool
+    # labels and taints.
+    if isinstance(result, dict) and result == {}:
+        return ExplicitEmptyDictValue()
+
+    if isinstance(result, list) and result == []:
+        return ExplicitEmptyListValue()
+
+    return result
+
 
 TYPES = {
     "string": str,
@@ -90,6 +105,12 @@ class ExplicitEmptyListValue:
     """
 
 
+class ExplicitEmptyDictValue:
+    """
+    A special type used to explicitly pass empty dictionaries to the API.
+    """
+
+
 def wrap_parse_nullable_value(arg_type: str) -> TYPES:
     """
     A helper function to parse `null` as None for nullable CLI args.

tests/integration/lke/test_clusters.py

@@ -330,7 +330,7 @@ def test_update_node_pool(test_lke_cluster):
     node_pool_id = get_node_pool_id(cluster_id)
     new_value = get_random_text(8) + "updated_pool"
 
-    result = (
+    result = json.loads(
         exec_test_command(
             BASE_CMD
             + [
@@ -341,16 +341,42 @@ def test_update_node_pool(test_lke_cluster):
                 "5",
                 "--labels",
                 json.dumps({"label-key": new_value}),
-                "--text",
-                "--no-headers",
-                "--format=label",
+                "--taints",
+                '[{"key": "test-key", "value": "test-value", "effect": "NoSchedule"}]',
+                "--json",
             ]
-        )
-        .stdout.decode()
-        .rstrip()
+        ).stdout.decode()
+    )
+
+    assert result[0]["labels"] == {"label-key": new_value}
+
+    assert result[0]["taints"] == [
+        {
+            "key": "test-key",
+            "value": "test-value",
+            "effect": "NoSchedule",
+        }
+    ]
+
+    # Reset the values for labels and taints (TPT-3665)
+    result = json.loads(
+        exec_test_command(
+            BASE_CMD
+            + [
+                "pool-update",
+                cluster_id,
+                node_pool_id,
+                "--labels",
+                "{}",
+                "--taints",
+                "[]",
+                "--json",
+            ]
+        ).stdout.decode()
     )
 
-    assert new_value in result
+    assert result[0]["labels"] == {}
+    assert result[0]["taints"] == []
 
 
 def test_view_node(test_lke_cluster):
@@ -407,7 +433,7 @@ def test_list_lke_types():
     assert "LKE High Availability" in types
 
 
-def test_create_node_pool_default_to_disk_encryption_disabled(test_lke_cluster):
+def test_create_node_pool_has_disk_encryption_field_set(test_lke_cluster):
     cluster_id = test_lke_cluster
 
     result = (
@@ -437,7 +463,7 @@ def test_create_node_pool_default_to_disk_encryption_disabled(test_lke_cluster):
 
     disk_encryption_status = pool_info.get("disk_encryption")
 
-    assert "disabled" in result
+    assert disk_encryption_status in ("enabled", "disabled")
     assert "g6-standard-4" in result
 
 

tests/integration/lke/test_lke_enterprise.py

@@ -1,6 +1,6 @@
 import json
+import re
 
-import pytest
 from pytest import MonkeyPatch
 
 from tests.integration.helpers import (
@@ -87,7 +87,6 @@ def test_create_lke_enterprise(monkeypatch: MonkeyPatch):
     )
 
 
-@pytest.mark.skip(reason="Commnad not available in spec < v4.198.0")
 def test_lke_tiered_versions_list():
     enterprise_tier_info_list = (
         exec_test_command(
@@ -106,7 +105,7 @@ def test_lke_tiered_versions_list():
 
     enterprise_ti = parsed[0]
 
-    assert enterprise_ti.get("id") == "v1.31.1+lke4"
+    assert re.match(r"^v\d+\.\d+\.\d+\+lke\d+$", enterprise_ti.get("id"))
     assert enterprise_ti.get("tier") == "enterprise"
 
     standard_tier_info_list = (
@@ -130,7 +129,6 @@ def test_lke_tiered_versions_list():
     assert s_ti_list[1].get("tier") == "standard"
 
 
-@pytest.mark.skip(reason="Commnad not available in spec < v4.198.0")
 def test_lke_tiered_versions_view():
     enterprise_tier_info = (
         exec_test_command(

tests/unit/test_api_request.py

@@ -12,7 +12,11 @@
 import requests
 
 from linodecli import api_request
-from linodecli.baked.operation import ExplicitEmptyListValue, ExplicitNullValue
+from linodecli.baked.operation import (
+    ExplicitEmptyDictValue,
+    ExplicitEmptyListValue,
+    ExplicitNullValue,
+)
 
 
 class TestAPIRequest:
@@ -597,6 +601,7 @@ def test_traverse_request_body(self):
                     "baz": ExplicitNullValue(),
                 },
                 "cool": [],
+                "pretty_cool": ExplicitEmptyDictValue(),
                 "cooler": ExplicitEmptyListValue(),
                 "coolest": ExplicitNullValue(),
             }
@@ -614,6 +619,7 @@ def test_traverse_request_body(self):
                 "foo": "bar",
                 "baz": None,
             },
+            "pretty_cool": {},
             "cooler": [],
             "coolest": None,
         }

tests/unit/test_operation.py

@@ -5,6 +5,8 @@
 
 from linodecli.baked import operation
 from linodecli.baked.operation import (
+    TYPES,
+    ExplicitEmptyDictValue,
     ExplicitEmptyListValue,
     ExplicitNullValue,
     OpenAPIOperation,
@@ -277,6 +279,41 @@ def test_array_arg_action_basic(self):
         result = parser.parse_args(["--foo", "foo", "--foo", "[]"])
         assert getattr(result, "foo") == ["foo", "[]"]
 
+    def test_object_arg_action_basic(self):
+        """
+        Tests a basic array argument condition..
+        """
+
+        parser = argparse.ArgumentParser(
+            prog=f"foo",
+        )
+
+        parser.add_argument(
+            "--foo",
+            metavar="foo",
+            type=TYPES["object"],
+        )
+
+        # User specifies a normal object (dict)
+        result = parser.parse_args(["--foo", '{"test-key": "test-value"}'])
+        assert getattr(result, "foo") == {"test-key": "test-value"}
+
+        # User specifies a normal object (list)
+        result = parser.parse_args(["--foo", '[{"test-key": "test-value"}]'])
+        assert getattr(result, "foo") == [{"test-key": "test-value"}]
+
+        # User wants an explicitly empty object (dict)
+        result = parser.parse_args(["--foo", "{}"])
+        assert isinstance(getattr(result, "foo"), ExplicitEmptyDictValue)
+
+        # User wants an explicitly empty object (list)
+        result = parser.parse_args(["--foo", "[]"])
+        assert isinstance(getattr(result, "foo"), ExplicitEmptyListValue)
+
+        # User doesn't specify the list
+        result = parser.parse_args([])
+        assert getattr(result, "foo") is None
+
     def test_resolve_api_components(self, get_openapi_for_api_components_tests):
         root = get_openapi_for_api_components_tests