- dict() -> model_dump() (Pydantic 2 stuff),

- lang/lang_version in saved script schemas
- lang/lang_version corresponding update in Editor component
- more unit tests (overall coverage ~95%)
- extra badge in readme

Author: HardMax71

.github/workflows/tests.yml

@@ -115,6 +115,14 @@ jobs:
           cd backend
           python -m pytest tests/integration -v --cov=app --cov-report=xml --cov-report=term
 
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: backend/coverage.xml
+          flags: backend
+          name: backend-coverage
+          fail_ci_if_error: false
+
       - name: Collect logs
         if: always()
         run: |

README.md

@@ -18,6 +18,9 @@
   <a href="https://github.com/HardMax71/Integr8sCode/actions/workflows/tests.yml">
     <img src="https://img.shields.io/github/actions/workflow/status/HardMax71/Integr8sCode/tests.yml?branch=main&label=tests&logo=pytest" alt="Tests Status" />
   </a>
+  <a href="https://codecov.io/gh/HardMax71/Integr8sCode">
+    <img src="https://img.shields.io/codecov/c/github/HardMax71/Integr8sCode?flag=backend&label=backend%20coverage&logo=codecov" alt="Backend Coverage" />
+  </a>
 </p>
 <p align="center">
   <a href="https://sonarcloud.io/dashboard?id=HardMax71_Integr8sCode">

backend/app/db/repositories/execution_repository.py

@@ -14,7 +14,7 @@ def __init__(self, db: AsyncIOMotorDatabase):
         self.collection: AsyncIOMotorCollection = self.db.get_collection("executions")
 
     async def create_execution(self, execution: ExecutionInDB) -> str:
-        execution_dict = execution.dict(by_alias=True)
+        execution_dict = execution.model_dump(by_alias=True)
         await self.collection.insert_one(execution_dict)
         return str(execution.id)
 

backend/app/db/repositories/saved_script_repository.py

@@ -11,7 +11,7 @@ def __init__(self, db: AsyncIOMotorDatabase):
         self.db = db
 
     async def create_saved_script(self, saved_script: SavedScriptInDB) -> str:
-        saved_script_dict = saved_script.dict(by_alias=True)
+        saved_script_dict = saved_script.model_dump(by_alias=True)
         await self.db.saved_scripts.insert_one(saved_script_dict)
         return str(saved_script.id)
 

backend/app/schemas/saved_script.py

@@ -8,6 +8,8 @@
 class SavedScriptBase(BaseModel):
     name: str
     script: str
+    lang: str = "python"
+    lang_version: str = "3.11"
     description: Optional[str] = None
 
 
@@ -29,6 +31,8 @@ class Config:
 class SavedScriptUpdate(BaseModel):
     name: Optional[str] = None
     script: Optional[str] = None
+    lang: Optional[str] = None
+    lang_version: Optional[str] = None
     description: Optional[str] = None
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 
@@ -41,6 +45,8 @@ class SavedScriptResponse(BaseModel):
     id: str
     name: str
     script: str
+    lang: str
+    lang_version: str
     description: Optional[str] = None
     created_at: datetime
     updated_at: datetime

backend/app/services/saved_script_service.py

@@ -21,7 +21,7 @@ async def create_saved_script(
             self, saved_script_create: SavedScriptCreate, user_id: str
     ) -> SavedScriptInDB:
         saved_script_in_db = SavedScriptInDB(
-            **saved_script_create.dict(), user_id=user_id
+            **saved_script_create.model_dump(), user_id=user_id
         )
         await self.saved_script_repo.create_saved_script(saved_script_in_db)
         return saved_script_in_db
@@ -32,7 +32,7 @@ async def get_saved_script(self, script_id: str, user_id: str) -> Optional[Saved
     async def update_saved_script(
             self, script_id: str, user_id: str, update_data: SavedScriptUpdate
     ) -> None:
-        update_dict = update_data.dict(exclude_unset=True)
+        update_dict = update_data.model_dump(exclude_unset=True)
         update_dict["updated_at"] = datetime.now(timezone.utc)
         await self.saved_script_repo.update_saved_script(
             script_id, user_id, update_dict

backend/tests/unit/__init__.py

@@ -0,0 +1,189 @@
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+from app.api.routes.auth import login, register, verify_token, logout
+from app.schemas.user import UserCreate
+from fastapi import HTTPException, Request, Response
+from fastapi.security import OAuth2PasswordRequestForm
+
+
+class TestAuthRoutesCoverage:
+
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        self.mock_request = Mock(spec=Request)
+        self.mock_response = Mock(spec=Response)
+        self.mock_response.set_cookie = Mock()
+        self.mock_response.delete_cookie = Mock()
+        self.mock_user_repo = AsyncMock()
+
+    def _setup_request(self, has_user_agent: bool = True) -> None:
+        if has_user_agent:
+            self.mock_request.headers = {"user-agent": "test-agent"}
+        else:
+            self.mock_request.headers = {}
+
+    @pytest.mark.asyncio
+    async def test_login_scenarios(self) -> None:
+        login_cases = [
+            ("nonexistent", "password", None, False, 401, "Invalid credentials"),
+            ("testuser", "wrongpassword", Mock(username="testuser"), False, 401, "Invalid credentials"),
+            ("testuser", "correctpassword", Mock(username="testuser"), True, None, None)
+        ]
+
+        for username, password, user_return, verify_password_result, expected_status, expected_detail in login_cases:
+            self._setup_request()
+
+            mock_form_data = Mock(spec=OAuth2PasswordRequestForm)
+            mock_form_data.username = username
+            mock_form_data.password = password
+
+            self.mock_user_repo.get_user.return_value = user_return
+
+            with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                if expected_status:
+                    with patch('app.api.routes.auth.security_service.verify_password',
+                               return_value=verify_password_result):
+                        with pytest.raises(HTTPException) as exc_info:
+                            await login(self.mock_request, self.mock_response, mock_form_data, self.mock_user_repo)
+
+                        assert exc_info.value.status_code == expected_status
+                        assert exc_info.value.detail == expected_detail
+                else:
+                    mock_settings = Mock(ACCESS_TOKEN_EXPIRE_MINUTES=30)
+                    with patch('app.api.routes.auth.security_service.verify_password', return_value=True):
+                        with patch('app.api.routes.auth.get_settings', return_value=mock_settings):
+                            with patch('app.api.routes.auth.security_service.create_access_token',
+                                       return_value="token"):
+                                with patch('app.api.routes.auth.security_service.generate_csrf_token',
+                                           return_value="csrf"):
+                                    result = await login(self.mock_request, self.mock_response, mock_form_data,
+                                                         self.mock_user_repo)
+
+                                    assert result["message"] == "Login successful"
+                                    assert result["username"] == "testuser"
+                                    assert result["csrf_token"] == "csrf"
+                                    assert self.mock_response.set_cookie.call_count == 2
+
+            self.mock_user_repo.reset_mock()
+            self.mock_response.reset_mock()
+
+    @pytest.mark.asyncio
+    async def test_register_scenarios(self) -> None:
+        register_cases = [
+            (Mock(), 400, "Username already registered", None),
+            (None, 500, "Error creating user", Exception("Database error")),
+            (None, None, None, Mock(username="newuser"))
+        ]
+
+        for existing_user, expected_status, expected_detail, create_result in register_cases:
+            self._setup_request()
+            mock_user_create = UserCreate(username="testuser", email="[email protected]", password="password")
+
+            self.mock_user_repo.get_user.return_value = existing_user
+            self.mock_user_repo.create_user.side_effect = None
+
+            with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                if expected_status:
+                    if expected_status == 500:
+                        self.mock_user_repo.create_user.side_effect = create_result
+                        with patch('app.api.routes.auth.security_service.get_password_hash', return_value="hashed"):
+                            with pytest.raises(HTTPException) as exc_info:
+                                await register(self.mock_request, mock_user_create, self.mock_user_repo)
+                    else:
+                        with pytest.raises(HTTPException) as exc_info:
+                            await register(self.mock_request, mock_user_create, self.mock_user_repo)
+
+                    assert exc_info.value.status_code == expected_status
+                    assert exc_info.value.detail == expected_detail
+                else:
+                    self.mock_user_repo.create_user.return_value = create_result
+                    with patch('app.api.routes.auth.security_service.get_password_hash', return_value="hashed"):
+                        with patch('app.api.routes.auth.UserResponse.model_validate') as mock_validate:
+                            mock_response = Mock()
+                            mock_validate.return_value = mock_response
+
+                            result = await register(self.mock_request, mock_user_create, self.mock_user_repo)
+                            assert result == mock_response
+
+            self.mock_user_repo.reset_mock()
+
+    @pytest.mark.asyncio
+    async def test_verify_token_scenarios(self) -> None:
+        mock_current_user = Mock(username="testuser")
+
+        verify_cases = [
+            (Mock(get=Mock(side_effect=Exception("Cookie error"))), 401, "Invalid token"),
+            ({"csrf_token": "csrf_value"}, None, "csrf_value"),
+            ({}, None, "")
+        ]
+
+        for cookies, expected_status, expected_csrf in verify_cases:
+            self._setup_request()
+            self.mock_request.cookies = cookies
+
+            with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                if expected_status:
+                    with pytest.raises(HTTPException) as exc_info:
+                        await verify_token(self.mock_request, mock_current_user)
+
+                    assert exc_info.value.status_code == expected_status
+                    assert exc_info.value.detail == "Invalid token"
+                else:
+                    result = await verify_token(self.mock_request, mock_current_user)
+
+                    assert result["valid"] is True
+                    assert result["username"] == "testuser"
+                    assert result["csrf_token"] == expected_csrf
+
+    @pytest.mark.asyncio
+    async def test_logout_successful(self) -> None:
+        self._setup_request()
+
+        with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+            result = await logout(self.mock_request, self.mock_response)
+
+            assert result["message"] == "Logout successful"
+            assert self.mock_response.delete_cookie.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_missing_user_agent_scenarios(self) -> None:
+        endpoints = [
+            ("login", lambda: login(self.mock_request, self.mock_response,
+                                    Mock(spec=OAuth2PasswordRequestForm, username="test", password="pass"),
+                                    self.mock_user_repo)),
+            ("register", lambda: register(self.mock_request,
+                                          UserCreate(username="test", email="[email protected]", password="pass"),
+                                          self.mock_user_repo)),
+            ("verify_token", lambda: verify_token(self.mock_request, Mock(username="testuser"))),
+            ("logout", lambda: logout(self.mock_request, self.mock_response))
+        ]
+
+        for endpoint_name, endpoint_func in endpoints:
+            self._setup_request(has_user_agent=False)
+
+            if endpoint_name == "register":
+                self.mock_user_repo.get_user.return_value = None
+                with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                    with patch('app.api.routes.auth.security_service.get_password_hash', return_value="hashed"):
+                        with patch('app.api.routes.auth.UserResponse.model_validate', return_value=Mock()):
+                            self.mock_user_repo.create_user.return_value = Mock(username="test")
+                            result = await endpoint_func()
+                            assert result is not None
+            elif endpoint_name == "verify_token":
+                self.mock_request.cookies = {"csrf_token": "csrf"}
+                with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                    result = await endpoint_func()
+                    assert result["valid"] is True
+            elif endpoint_name == "logout":
+                with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                    result = await endpoint_func()
+                    assert result["message"] == "Logout successful"
+            else:
+                self.mock_user_repo.get_user.return_value = None
+                with patch('app.api.routes.auth.get_remote_address', return_value="127.0.0.1"):
+                    with pytest.raises(HTTPException):
+                        await endpoint_func()
+
+            self.mock_user_repo.reset_mock()
+            self.mock_response.reset_mock()