JWT_SECRET_KEY fix 2: naming

Author: Max Azatian

backend/.env

@@ -1,5 +1,5 @@
 PROJECT_NAME=integr8scode
-JWT_SECRET_KEY=your_secret_key_here
+SECRET_KEY=your_secret_key_here
 ALGORITHM=HS256
 ACCESS_TOKEN_EXPIRE_MINUTES=30
 MONGODB_URL=mongodb://mongo:27017/integr8scode

backend/app/config.py

@@ -9,7 +9,7 @@
 class Settings(BaseSettings):
     PROJECT_NAME: str = "integr8scode"
     API_V1_STR: str = "/api/v1"
-    SECRET_KEY: str = Field(default=None, env="JWT_SECRET_KEY")
+    SECRET_KEY: str = Field(default=None)
     ALGORITHM: str = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
     MONGODB_URL: str = "mongodb://mongo:27017/integr8scode"
@@ -47,11 +47,11 @@ class Settings(BaseSettings):
     @classmethod
     def validate_secret_key(cls, v: Optional[str]) -> str:
         if not v:
-            raise ValueError("JWT_SECRET_KEY environment variable must be set")
+            raise ValueError("SECRET_KEY environment variable must be set")
         if len(v) < 32:
-            raise ValueError("JWT_SECRET_KEY must be at least 32 characters long")
+            raise ValueError("SECRET_KEY must be at least 32 characters long")
         if v == "your_secret_key_here" or v == "default_secret_key":
-            raise ValueError("JWT_SECRET_KEY must not use default placeholder values")
+            raise ValueError("SECRET_KEY must not use default placeholder values")
         return v
 
     class Config:

backend/tests/unit/test_config.py

@@ -8,47 +8,55 @@
 
 
 class TestSettingsValidation:
-    def test_secret_key_missing(self):
+    def test_secret_key_missing(self) -> None:
         with mock.patch.dict(os.environ, {}, clear=True):
             with pytest.raises(ValidationError) as exc_info:
                 Settings()
 
             errors = exc_info.value.errors()
             assert len(errors) == 1
             assert errors[0]["loc"] == ("SECRET_KEY",)
-            assert "JWT_SECRET_KEY environment variable must be set" in errors[0]["msg"]
+            assert "SECRET_KEY environment variable must be set" in errors[0]["msg"]
 
-    def test_secret_key_too_short(self):
-        with mock.patch.dict(os.environ, {"JWT_SECRET_KEY": "short_key"}, clear=True):
+    def test_secret_key_too_short(self) -> None:
+        with mock.patch.dict(os.environ, {"SECRET_KEY": "short_key"}, clear=True):
             with pytest.raises(ValidationError) as exc_info:
                 Settings()
 
             errors = exc_info.value.errors()
             assert len(errors) == 1
             assert errors[0]["loc"] == ("SECRET_KEY",)
-            assert "JWT_SECRET_KEY must be at least 32 characters long" in errors[0]["msg"]
+            assert "SECRET_KEY must be at least 32 characters long" in errors[0]["msg"]
 
-    def test_secret_key_default_placeholder(self):
+    def test_secret_key_default_placeholder(self) -> None:
         test_cases = ["your_secret_key_here", "default_secret_key"]
 
         for placeholder in test_cases:
-            with mock.patch.dict(os.environ, {"JWT_SECRET_KEY": placeholder}, clear=True):
+            with mock.patch.dict(os.environ, {"SECRET_KEY": placeholder}, clear=True):
                 with pytest.raises(ValidationError) as exc_info:
                     Settings()
 
                 errors = exc_info.value.errors()
                 assert len(errors) == 1
                 assert errors[0]["loc"] == ("SECRET_KEY",)
-                assert "JWT_SECRET_KEY must not use default placeholder values" in errors[0]["msg"]
+                assert "SECRET_KEY must not use default placeholder values" in errors[0]["msg"]
 
-    def test_secret_key_valid(self):
+    def test_secret_key_valid(self) -> None:
         valid_key = "a" * 32  # 32 character key
-        with mock.patch.dict(os.environ, {"JWT_SECRET_KEY": valid_key}, clear=True):
+        with mock.patch.dict(os.environ, {"SECRET_KEY": valid_key}, clear=True):
             settings = Settings()
             assert settings.SECRET_KEY == valid_key
 
-    def test_secret_key_longer_than_minimum(self):
+    def test_secret_key_longer_than_minimum(self) -> None:
         long_key = "a" * 64  # 64 character key
-        with mock.patch.dict(os.environ, {"JWT_SECRET_KEY": long_key}, clear=True):
+        with mock.patch.dict(os.environ, {"SECRET_KEY": long_key}, clear=True):
             settings = Settings()
-            assert settings.SECRET_KEY == long_key
+            assert settings.SECRET_KEY == long_key
+
+    def test_env_file_loading(self) -> None:
+        """Test that .env file is loaded if present."""
+        # This test verifies that the env_file configuration works
+        # In a real scenario, the .env file would contain SECRET_KEY
+        with mock.patch.dict(os.environ, {"SECRET_KEY": "a" * 32}, clear=True):
+            settings = Settings()
+            assert settings.Config.env_file == ".env"