Use .model_dump(mode='json') to create a real dict

Using EnvConfig.from_dict() creates an EnvConfig object that
is not always preferable. The above method call creates a real
dict with all objects resolved to basic types like strings,
bools, int etc.

Author: tomschr

src/docbuild/cli/cmd_cli.py

@@ -183,7 +183,7 @@ def cli(
     try:
         # Pydantic validation handles placeholder replacement via @model_validator
         # The result is the validated Pydantic object, stored in context.envconfig
-        context.envconfig = EnvConfig.from_dict(raw_envconfig)
+        context.envconfig = EnvConfig.from_dict(raw_envconfig).model_dump(mode='json')
     except (ValueError, ValidationError) as e:
         log.error(
              "Environment configuration failed validation: "

tests/cli/test_cmd_cli.py

@@ -8,7 +8,7 @@
 import docbuild.cli.cmd_cli as cli_mod
 from docbuild.cli.context import DocBuildContext
 from docbuild.models.config_model.app import AppConfig
-from docbuild.models.config_model.env import EnvConfig 
+from docbuild.models.config_model.env import EnvConfig
 
 cli = cli_mod.cli
 
@@ -25,14 +25,12 @@ def capture(ctx):
 
 @pytest.fixture
 def mock_config_models(monkeypatch):
-    """
-    Fixture to mock AppConfig.from_dict and EnvConfig.from_dict.
-    
+    """Fixture to mock AppConfig.from_dict and EnvConfig.from_dict.
+
     Ensures the mock AppConfig instance has the necessary
     logging attributes and methods (.logging.model_dump) that the CLI calls
     during setup_logging.
     """
-    
     # Mock the nested logging attribute and its model_dump method
     mock_logging_dump = Mock(return_value={'version': 1, 'log_setup': True})
     mock_logging_attribute = Mock()
@@ -42,21 +40,26 @@ def mock_config_models(monkeypatch):
     mock_app_instance = Mock(spec=AppConfig)
     # Assign the mock logging attribute to the app instance
     mock_app_instance.logging = mock_logging_attribute
-    
+
     # Env config mock doesn't need logging setup
+    # The CLI calls .model_dump() on the instance, so we mock that call.
+    mock_env_dump = Mock(return_value={'env_data': 'from_mock_dump'})
     mock_env_instance = Mock(spec=EnvConfig)
-    
+    mock_env_instance.model_dump.return_value = mock_env_dump
+
     # Mock the static methods that perform validation
     mock_app_from_dict = Mock(return_value=mock_app_instance)
     mock_env_from_dict = Mock(return_value=mock_env_instance)
-    
+
+
     # Patch the actual classes
     monkeypatch.setattr(AppConfig, 'from_dict', mock_app_from_dict)
     monkeypatch.setattr(EnvConfig, 'from_dict', mock_env_from_dict)
-    
+
     return {
         'app_instance': mock_app_instance,
         'env_instance': mock_env_instance,
+        'env_dump': mock_env_dump,
         'app_from_dict': mock_app_from_dict,
         'env_from_dict': mock_env_from_dict,
     }
@@ -79,26 +82,29 @@ def fake_handle_config(user_path, *a, **kw):
         return (Path('default_env.toml'),), {'env_data': 'from_default'}, True
 
     monkeypatch.setattr(cli_mod, 'handle_config', fake_handle_config)
-    
+
     context = DocBuildContext()
-    
+
     result = runner.invoke(
-        cli, 
+        cli,
         ['--app-config', str(app_file), 'capture'],
         obj=context,
         catch_exceptions=False
     )
-    
+
     assert result.exit_code == 0
     assert 'capture' in result.output.strip()
-    
+
     # Assert that the raw data was passed to the Pydantic models
     mock_config_models['app_from_dict'].assert_called_once()
     mock_config_models['env_from_dict'].assert_called_once()
-    
-    # Assert that the context now holds the MOCKED VALIDATED OBJECTS
+
+    # Assert that the context holds the app's Pydantic model instance
     assert context.appconfig is mock_config_models['app_instance']
-    assert context.envconfig is mock_config_models['env_instance']
+
+    # Assert that the context holds the DICTIONARY from model_dump()
+    # for the environment config.
+    assert context.envconfig is mock_config_models['env_dump']
     assert context.envconfig_from_defaults is True
 
 
@@ -107,15 +113,15 @@ def test_cli_with_app_and_env_config(monkeypatch, runner, tmp_path, mock_config_
     # Create real temporary files for Click to validate
     app_file = tmp_path / 'app.toml'
     env_file = tmp_path / 'env.toml'
-    app_file.write_text('[logging]\nversion=1') 
+    app_file.write_text('[logging]\nversion=1')
     env_file.write_text('dummy = true')
 
     def fake_handle_config(user_path, *a, **kw):
         if str(user_path) == str(app_file):
             return (app_file,), {'logging': {'version': 1}}, False
         if str(user_path) == str(env_file):
             return (env_file,), {'server': {'host': '1.2.3.4'}}, False
-        return (None,), {'default_data': 'default_content'}, True 
+        return (None,), {'default_data': 'default_content'}, True
 
     monkeypatch.setattr(cli_mod, 'handle_config', fake_handle_config)
 
@@ -130,9 +136,9 @@ def fake_handle_config(user_path, *a, **kw):
             'capture',
         ],
         obj=context,
-        catch_exceptions=False, 
+        catch_exceptions=False,
     )
-    
+
     # Check for success and context variables
     assert result.exit_code == 0
 
@@ -141,7 +147,7 @@ def fake_handle_config(user_path, *a, **kw):
 
     # Assert that the context now holds the MOCKED VALIDATED OBJECTS
     assert context.appconfig is mock_config_models['app_instance']
-    assert context.envconfig is mock_config_models['env_instance']
+    assert context.envconfig is mock_config_models['env_dump']
     assert context.envconfigfiles == (env_file,)
     assert context.envconfig_from_defaults is False
 
@@ -151,44 +157,44 @@ def test_cli_config_validation_failure(
     monkeypatch, runner, tmp_path, mock_config_models, is_app_config_failure
 ):
     """Test that the CLI handles Pydantic validation errors gracefully for both configs."""
-    
+
     app_file = tmp_path / 'app.toml'
-    app_file.write_text('bad data') 
-    
+    app_file.write_text('bad data')
+
     # 1. Mock the log.error function to check output
     mock_log_error = Mock()
     monkeypatch.setattr(cli_mod.log, 'error', mock_log_error)
 
     # 2. Configure the Pydantic mocks to simulate failure
     mock_validation_error = ValidationError.from_exception_data(
-        'TestModel', 
+        'TestModel',
         [
             {
-                'type': 'int_parsing', 
+                'type': 'int_parsing',
                 'loc': ('server', 'port'),
                 'input': 'not_an_int',
             }
         ]
     )
-    
+
     # Define the simple error structure that the CLI error formatting relies on:
     MOCK_ERROR_DETAIL = {
-        'loc': ('server', 'port'), 
-        'msg': 'value is not a valid integer (mocked)', 
+        'loc': ('server', 'port'),
+        'msg': 'value is not a valid integer (mocked)',
         'input': 'not_an_int'
     }
 
-    
+
     if is_app_config_failure:
         mock_config_models['app_from_dict'].side_effect = mock_validation_error
     else:
         mock_config_models['env_from_dict'].side_effect = mock_validation_error
-    
+
     # 3. Mock handle_config to return raw data successfully (no file read error)
     def fake_handle_config(user_path, *a, **kw):
         if user_path == app_file:
             return (app_file,), {'raw_app_data': 'x'}, False
-        return (Path('env.toml'),), {'raw_env_data': 'y'}, False 
+        return (Path('env.toml'),), {'raw_env_data': 'y'}, False
 
     monkeypatch.setattr(cli_mod, 'handle_config', fake_handle_config)
 
@@ -199,28 +205,28 @@ def fake_handle_config(user_path, *a, **kw):
         obj=context,
         catch_exceptions=True,
     )
-    
+
     # 4. Assertions
-    assert result.exit_code == 1 
-    
+    assert result.exit_code == 1
+
     if is_app_config_failure:
         assert 'Application configuration failed validation' in mock_log_error.call_args_list[0][0][0]
     else:
         assert 'Environment configuration failed validation' in mock_log_error.call_args_list[0][0][0]
-    
+
     # --- REMOVE FRAGILE ASSERTIONS ON LOG CALL COUNT ---
-    # assert mock_log_error.call_count > 1 
+    # assert mock_log_error.call_count > 1
     # assert mock_log_error.call_count >= 2
     # assert any("Field: (" in call[0][0] for call in mock_log_error.call_args_list)
 
-    assert mock_log_error.call_count >= 1 
+    assert mock_log_error.call_count >= 1
 
 
 def test_cli_verbose_and_debug(monkeypatch, runner, tmp_path, mock_config_models):
     """Test that verbosity and debug flags are passed correctly to context."""
     # Create a real temporary file for Click to validate
     app_file = tmp_path / 'app.toml'
-    app_file.write_text('[logging]\nversion=1') 
+    app_file.write_text('[logging]\nversion=1')
 
     def fake_handle_config(user_path, *a, **kw):
         if user_path == app_file:
@@ -237,13 +243,13 @@ def fake_handle_config(user_path, *a, **kw):
         obj=context,
         catch_exceptions=False,
     )
-    
+
     # Check for success and context variables
     assert result.exit_code == 0
     assert 'capture\n' in result.output
     assert context.verbose == 3
     assert context.debug is True
-    
+
     # Assertions on config structure must now reference the MOCKED Pydantic objects
     assert context.appconfig is mock_config_models['app_instance']
-    assert context.envconfig is mock_config_models['env_instance']
+    assert context.envconfig is mock_config_models['env_dump']