From 49cd41e2e4eef6df3f06482a149c41b92c502e7a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 21 Mar 2026 17:26:17 +0000 Subject: [PATCH] test: improve test coverage for app/utils/setup_wizard.py Expand test suite from 13 to 36 tests while maintaining 100% coverage. Add edge case tests for each placeholder value, setting metadata validation, step content verification, and exception handling. Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com> Agent-Logs-Url: https://github.com/christianlouis/DocuElevate/sessions/590410bf-fce9-4abf-bea0-c6c80864e36a --- tests/test_setup_wizard.py | 243 ++++++++++++++++++++++++++++++++++--- 1 file changed, 229 insertions(+), 14 deletions(-) diff --git a/tests/test_setup_wizard.py b/tests/test_setup_wizard.py index a7e1a30f..3b2c39e8 100644 --- a/tests/test_setup_wizard.py +++ b/tests/test_setup_wizard.py @@ -36,6 +36,63 @@ class TestGetRequiredSettings: assert "session_secret" in keys assert "openai_api_key" in keys + def test_sensitive_flags_correct(self): + """Test that sensitive flag is set correctly for each setting.""" + settings_map = {s["key"]: s for s in get_required_settings()} + # Sensitive settings + assert settings_map["session_secret"]["sensitive"] is True + assert settings_map["admin_password"]["sensitive"] is True + assert settings_map["openai_api_key"]["sensitive"] is True + # Non-sensitive settings + assert settings_map["database_url"]["sensitive"] is False + assert settings_map["redis_url"]["sensitive"] is False + assert settings_map["workdir"]["sensitive"] is False + assert settings_map["admin_username"]["sensitive"] is False + + def test_wizard_step_assignments(self): + """Test that settings are assigned to the correct wizard steps.""" + settings_map = {s["key"]: s for s in get_required_settings()} + # Step 1: Core infrastructure + assert settings_map["database_url"]["wizard_step"] == 1 + assert settings_map["redis_url"]["wizard_step"] == 1 + assert settings_map["workdir"]["wizard_step"] == 1 + assert settings_map["gotenberg_url"]["wizard_step"] == 1 + # Step 2: Security + assert settings_map["session_secret"]["wizard_step"] == 2 + assert settings_map["admin_username"]["wizard_step"] == 2 + assert settings_map["admin_password"]["wizard_step"] == 2 + # Step 3: AI Services + assert settings_map["ai_provider"]["wizard_step"] == 3 + assert settings_map["openai_api_key"]["wizard_step"] == 3 + assert settings_map["openai_model"]["wizard_step"] == 3 + + def test_wizard_categories_correct(self): + """Test that wizard categories are set correctly.""" + settings_map = {s["key"]: s for s in get_required_settings()} + assert settings_map["database_url"]["wizard_category"] == "Core Infrastructure" + assert settings_map["session_secret"]["wizard_category"] == "Security" + assert settings_map["ai_provider"]["wizard_category"] == "AI Services" + + def test_ai_provider_has_options(self): + """Test that ai_provider setting has a list of options.""" + settings_map = {s["key"]: s for s in get_required_settings()} + ai_provider = settings_map["ai_provider"] + assert "options" in ai_provider + assert isinstance(ai_provider["options"], list) + assert len(ai_provider["options"]) > 0 + assert "openai" in ai_provider["options"] + + def test_settings_have_string_type(self): + """Test that all settings have the 'string' type.""" + for setting in get_required_settings(): + assert setting["type"] == "string", f"Expected string type for {setting['key']}" + + def test_total_settings_count(self): + """Test that the expected number of required settings is returned.""" + # Ensures no accidental additions or removals + result = get_required_settings() + assert len(result) == 10 + @pytest.mark.unit class TestIsSetupRequired: @@ -46,32 +103,55 @@ class TestIsSetupRequired: result = is_setup_required() assert isinstance(result, bool) - def test_setup_required_with_test_key(self): - """Test that setup is required when using test-key placeholder.""" - # In test environment, openai_api_key is "test-key" which is a placeholder + def test_setup_required_when_admin_password_is_none(self): + """Test that setup is required when admin_password is None (test environment default).""" + # In the test environment, admin_password defaults to None which is a placeholder value result = is_setup_required() assert result is True @patch("app.utils.setup_wizard.settings") def test_setup_not_required_with_real_values(self, mock_settings): - """Test that setup is not required with real values.""" + """Test that setup is not required when both critical settings have real values. + + is_setup_required() only checks session_secret and admin_password, so only + these two attributes need to be configured on the mock. + """ mock_settings.session_secret = "a_very_long_real_session_secret_that_is_definitely_not_placeholder" mock_settings.admin_password = "my_real_secure_password_123" - mock_settings.openai_api_key = "sk-real-key-12345" - mock_settings.azure_ai_key = "real-azure-key-12345" result = is_setup_required() assert result is False @patch("app.utils.setup_wizard.settings") - def test_handles_exception_gracefully(self, mock_settings): - """Test that exceptions are handled gracefully.""" - mock_settings.session_secret = property(lambda self: (_ for _ in ()).throw(Exception("test"))) - # getattr on a mock with side_effect - type(mock_settings).session_secret = property(lambda s: (_ for _ in ()).throw(RuntimeError("boom"))) - # This should not raise - it returns False on error + def test_setup_required_with_insecure_session_secret(self, mock_settings): + """Test that setup is required when session_secret is the insecure default.""" + mock_settings.session_secret = "INSECURE_DEFAULT_FOR_DEVELOPMENT_ONLY_DO_NOT_USE_IN_PRODUCTION_MINIMUM_32_CHARS" + mock_settings.admin_password = "real_password_123" result = is_setup_required() - # May return True or False depending on which setting fails, but shouldn't raise - assert isinstance(result, bool) + assert result is True + + @pytest.mark.parametrize( + "placeholder", + [None, "", "your_secure_password", "changeme", "admin"], + ) + @patch("app.utils.setup_wizard.settings") + def test_setup_required_for_each_admin_password_placeholder(self, mock_settings, placeholder): + """Test that setup is required for each admin_password placeholder value.""" + mock_settings.session_secret = "a_very_long_real_session_secret_that_is_definitely_not_placeholder" + mock_settings.admin_password = placeholder + result = is_setup_required() + assert result is True + + @patch("app.utils.setup_wizard.settings") + def test_handles_exception_gracefully(self, mock_settings): + """Test that exceptions are handled gracefully and return False (fail open).""" + + def raise_error(): + raise RuntimeError("boom") + + type(mock_settings).session_secret = property(lambda s: raise_error()) + # This should not raise - it returns False on error (fail open) + result = is_setup_required() + assert result is False @pytest.mark.unit @@ -89,6 +169,102 @@ class TestGetMissingRequiredSettings: # In test environment, openai_api_key is "test-key" which is a placeholder assert "openai_api_key" in missing + @patch("app.utils.setup_wizard.settings") + def test_returns_empty_when_all_configured(self, mock_settings): + """Test that returns empty list when all settings are properly configured.""" + mock_settings.database_url = "sqlite:///./real.db" + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "a_very_long_real_session_secret_minimum_32_chars" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "real_secure_password_456" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "sk-real-key-12345" + mock_settings.openai_model = "gpt-4o-mini" + result = get_missing_required_settings() + assert result == [] + + @patch("app.utils.setup_wizard.settings") + def test_detects_none_value_as_missing(self, mock_settings): + """Test that a None value is detected as missing.""" + mock_settings.database_url = None + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "a_very_long_real_session_secret_minimum_32_chars" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "real_secure_password_456" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "sk-real-key-12345" + mock_settings.openai_model = "gpt-4o-mini" + missing = get_missing_required_settings() + assert "database_url" in missing + + @patch("app.utils.setup_wizard.settings") + def test_detects_empty_string_as_missing(self, mock_settings): + """Test that an empty string value is detected as missing.""" + mock_settings.database_url = "sqlite:///./real.db" + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "a_very_long_real_session_secret_minimum_32_chars" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "sk-real-key-12345" + mock_settings.openai_model = "gpt-4o-mini" + missing = get_missing_required_settings() + assert "admin_password" in missing + + @patch("app.utils.setup_wizard.settings") + def test_detects_insecure_default_as_missing(self, mock_settings): + """Test that the insecure default session_secret is detected as missing.""" + mock_settings.database_url = "sqlite:///./real.db" + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "INSECURE_DEFAULT_FOR_DEVELOPMENT_ONLY_DO_NOT_USE_IN_PRODUCTION_MINIMUM_32_CHARS" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "real_secure_password_456" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "sk-real-key-12345" + mock_settings.openai_model = "gpt-4o-mini" + missing = get_missing_required_settings() + assert "session_secret" in missing + + @patch("app.utils.setup_wizard.settings") + def test_detects_placeholder_bracket_format_as_missing(self, mock_settings): + """Test that formatted placeholders are detected as missing.""" + mock_settings.database_url = "sqlite:///./real.db" + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "a_very_long_real_session_secret_minimum_32_chars" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "real_secure_password_456" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "" + mock_settings.openai_model = "gpt-4o-mini" + missing = get_missing_required_settings() + assert "openai_api_key" in missing + + @patch("app.utils.setup_wizard.settings") + def test_detects_test_key_placeholder_as_missing(self, mock_settings): + """Test that 'test-key' is detected as a missing placeholder.""" + mock_settings.database_url = "sqlite:///./real.db" + mock_settings.redis_url = "redis://localhost:6379/0" + mock_settings.workdir = "/data/workdir" + mock_settings.gotenberg_url = "http://gotenberg:3000" + mock_settings.session_secret = "a_very_long_real_session_secret_minimum_32_chars" + mock_settings.admin_username = "admin" + mock_settings.admin_password = "real_secure_password_456" + mock_settings.ai_provider = "openai" + mock_settings.openai_api_key = "test-key" + mock_settings.openai_model = "gpt-4o-mini" + missing = get_missing_required_settings() + assert "openai_api_key" in missing + @pytest.mark.unit class TestGetWizardSteps: @@ -121,3 +297,42 @@ class TestGetWizardSteps: required_keys = [s["key"] for s in get_required_settings()] for key in required_keys: assert key in all_step_keys, f"Setting {key} not assigned to any wizard step" + + def test_has_three_steps(self): + """Test that there are exactly three wizard steps.""" + steps = get_wizard_steps() + assert len(steps) == 3 + assert set(steps.keys()) == {1, 2, 3} + + def test_step_1_contains_infrastructure_settings(self): + """Test that step 1 contains the core infrastructure settings.""" + steps = get_wizard_steps() + step_1_keys = [s["key"] for s in steps[1]] + assert "database_url" in step_1_keys + assert "redis_url" in step_1_keys + assert "workdir" in step_1_keys + assert "gotenberg_url" in step_1_keys + + def test_step_2_contains_security_settings(self): + """Test that step 2 contains the security settings.""" + steps = get_wizard_steps() + step_2_keys = [s["key"] for s in steps[2]] + assert "session_secret" in step_2_keys + assert "admin_username" in step_2_keys + assert "admin_password" in step_2_keys + + def test_step_3_contains_ai_settings(self): + """Test that step 3 contains the AI service settings.""" + steps = get_wizard_steps() + step_3_keys = [s["key"] for s in steps[3]] + assert "ai_provider" in step_3_keys + assert "openai_api_key" in step_3_keys + assert "openai_model" in step_3_keys + + def test_settings_not_duplicated_across_steps(self): + """Test that no setting appears in more than one step.""" + steps = get_wizard_steps() + all_keys = [] + for settings_list in steps.values(): + all_keys.extend([s["key"] for s in settings_list]) + assert len(all_keys) == len(set(all_keys)), "Some settings appear in multiple steps"