rework StackletConfig more

Author: albertodonato

stacklet/client/platform/cli.py

@@ -1,8 +1,6 @@
 # Copyright Stacklet, Inc.
 # SPDX-License-Identifier: Apache-2.0
 
-import json
-import os
 import pathlib
 from urllib.parse import urlsplit, urlunsplit
 
@@ -128,24 +126,18 @@ def configure(
     """
     Interactively save a Stacklet Config file
     """
-    config = {
-        "api": api,
-        "region": region,
-        "cognito_client_id": cognito_client_id,
-        "cognito_user_pool_id": cognito_user_pool_id,
-        "idp_id": idp_id,
-        "auth_url": auth_url,
-        "cubejs": cubejs,
-    }
-
-    StackletConfig.validate(config)
-
-    if not os.path.exists(location):
-        dirs = location.rsplit("/", 1)[0]
-        os.makedirs(os.path.expanduser(dirs), exist_ok=True)
-
-    with open(os.path.expanduser(location), "w+") as f:
-        f.write(json.dumps(config))
+    config = StackletConfig.from_dict(
+        {
+            "api": api,
+            "region": region,
+            "cognito_client_id": cognito_client_id,
+            "cognito_user_pool_id": cognito_user_pool_id,
+            "idp_id": idp_id,
+            "auth_url": auth_url,
+            "cubejs": cubejs,
+        }
+    )
+    config.to_file(location)
     click.echo(f"Saved config to {location}")
 
 
@@ -277,13 +269,9 @@ def auto_configure(url, prefix, idp, location):
     except KeyError as err:
         raise click.ClickException(f"The configuration details are missing a required key: {err}")
 
-    config_file = location.expanduser()
-    if not config_file.exists():
-        config_file.parent.mkdir(parents=True, exist_ok=True)
-
-    config_file.write_text(json.dumps(formatted_config, indent=4, sort_keys=True))
-
-    click.echo(f"Saved config to {config_file}")
+    config = StackletConfig.from_dict(formatted_config)
+    config.to_file(location)
+    click.echo(f"Saved config to {location}")
 
 
 @cli.command()
@@ -297,7 +285,7 @@ def show(obj):
         id_details = jwt.decode(id_token, options={"verify_signature": False})
         click.echo(fmt(id_details))
         click.echo()
-    click.echo(fmt(obj.config.to_json()))
+    click.echo(fmt(obj.config.to_dict()))
 
 
 @cli.command(short_help="Login to Stacklet")

stacklet/client/platform/config.py

@@ -22,6 +22,8 @@
 
 DEFAULT_OUTPUT_FORMAT = "yaml"
 
+JSONDict = dict[str, t.Any]
+
 
 class StackletConfig:
     schema = {
@@ -35,6 +37,15 @@ class StackletConfig:
             "auth_url": {"type": "string"},
             "cubejs": {"type": "string"},
         },
+        "required": [
+            "api",
+            "cognito_user_pool_id",
+            "cognito_client_id",
+            "region",
+            "idp_id",
+            "auth_url",
+            "cubejs",
+        ],
     }
 
     def __init__(
@@ -55,7 +66,12 @@ def __init__(
         self.auth_url = auth_url
         self.cubejs = cubejs
 
-    def to_json(self):
+    @classmethod
+    def from_dict(cls, config: JSONDict):
+        cls.validate(config)
+        return cls(**config)
+
+    def to_dict(self) -> JSONDict:
         return dict(
             api=self.api,
             cognito_user_pool_id=self.cognito_user_pool_id,
@@ -66,27 +82,28 @@ def to_json(self):
             cubejs=self.cubejs,
         )
 
-    @classmethod
-    def validate(cls, config):
-        try:
-            validate(instance=config, schema=cls.schema)
-        except ValidationError as err:
-            raise ConfigValidationException(str(err))
+    def to_file(self, filename):
+        path = Path(filename).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w") as fd:
+            json.dump(self.to_dict(), fd, indent=4, sort_keys=True)
 
     @classmethod
     def from_file(cls, filename):
         path = Path(filename).expanduser()
         if path.exists():
             with path.open() as f:
-                content = json.load(f)
+                config = json.load(f)
         else:
-            content = {}
-
-        cls.validate(content)
-        return cls(**content)
-
+            config = {}
+        return cls.from_dict(config)
 
-JSONDict = dict[str, t.Any]
+    @classmethod
+    def validate(cls, config: JSONDict):
+        try:
+            validate(instance=config, schema=cls.schema)
+        except ValidationError as err:
+            raise ConfigValidationException(str(err))
 
 
 class StackletCredentials:

tests/test_config.py

@@ -1,10 +1,12 @@
+import json
 import os
 from contextlib import contextmanager
 from unittest.mock import patch
 
 import pytest
 
-from stacklet.client.platform.config import StackletCredentials
+from stacklet.client.platform.config import StackletConfig, StackletCredentials
+from stacklet.client.platform.exceptions import ConfigValidationException
 
 
 @pytest.fixture
@@ -45,3 +47,87 @@ def test_api_token_prefer_env(self, creds):
         creds.write("id token", "access token")
         with self.env_api_key("a-b-c"):
             assert creds.api_token() == "a-b-c"
+
+
+class TestStackletConfig:
+    @pytest.fixture
+    def config(self):
+        return {
+            "api": "https://api.example.com",
+            "cognito_user_pool_id": "pool-123",
+            "cognito_client_id": "client-456",
+            "region": "us-east-1",
+            "idp_id": "idp-789",
+            "auth_url": "https://auth.example.com",
+            "cubejs": "https://cubejs.example.com",
+        }
+
+    def test_validate_validpresent(self, config):
+        StackletConfig.validate(config)
+
+    @pytest.mark.parametrize(
+        "missing_field",
+        [
+            "api",
+            "cognito_user_pool_id",
+            "cognito_client_id",
+            "region",
+            "idp_id",
+            "auth_url",
+            "cubejs",
+        ],
+    )
+    def test_validate_missing_required_field(self, config, missing_field):
+        config_copy = config.copy()
+        del config_copy[missing_field]
+        with pytest.raises(ConfigValidationException) as err:
+            StackletConfig.validate(config_copy)
+        assert f"'{missing_field}' is a required property" in str(err.value)
+
+    def test_from_file_valid_config(self, config, tmp_path):
+        config_file = tmp_path / "config.json"
+        config_file.write_text(json.dumps(config))
+        stacklet_config = StackletConfig.from_file(config_file)
+        assert stacklet_config.api == config["api"]
+        assert stacklet_config.cognito_user_pool_id == config["cognito_user_pool_id"]
+        assert stacklet_config.cognito_client_id == config["cognito_client_id"]
+        assert stacklet_config.region == config["region"]
+        assert stacklet_config.idp_id == config["idp_id"]
+        assert stacklet_config.auth_url == config["auth_url"]
+        assert stacklet_config.cubejs == config["cubejs"]
+
+    def test_from_file_missing_file(self, tmp_path):
+        config_file = tmp_path / "nonexistent.json"
+        with pytest.raises(ConfigValidationException):
+            StackletConfig.from_file(config_file)
+
+    def test_from_file_invalid_config(self, tmp_path):
+        config_file = tmp_path / "config.json"
+        incomplete_config = {"api": "https://api.example.com"}
+        config_file.write_text(json.dumps(incomplete_config))
+        with pytest.raises(ConfigValidationException):
+            StackletConfig.from_file(config_file)
+
+    def test_to_file(self, config, tmp_path):
+        config_file = tmp_path / "output.json"
+        stacklet_config = StackletConfig(**config)
+        stacklet_config.to_file(config_file)
+        assert config_file.exists()
+
+        loaded_config = StackletConfig.from_file(config_file)
+        assert loaded_config.api == config["api"]
+        assert loaded_config.cognito_user_pool_id == config["cognito_user_pool_id"]
+        assert loaded_config.cognito_client_id == config["cognito_client_id"]
+        assert loaded_config.region == config["region"]
+        assert loaded_config.idp_id == config["idp_id"]
+        assert loaded_config.auth_url == config["auth_url"]
+        assert loaded_config.cubejs == config["cubejs"]
+
+    def test_to_file_creates_parent_directories(self, config, tmp_path):
+        config_file = tmp_path / "nested" / "dir" / "config.json"
+        stacklet_config = StackletConfig(**config)
+        stacklet_config.to_file(config_file)
+        assert config_file.exists()
+
+        loaded_config = StackletConfig.from_file(config_file)
+        assert loaded_config.api == config["api"]