fix: fix unit testcases

code/backend/batch/local.settings.json.sample

@@ -2,7 +2,7 @@
     "IsEncrypted": false,
     "Values": {
       "FUNCTIONS_WORKER_RUNTIME": "python",
-      "AzureWebJobsStorage": "",
+      "AzureWebJobsStorage__accountName": "",
       "MyBindingConnection": "",
       "AzureWebJobs.HttpExample.Disabled": "true"
     },
@@ -11,4 +11,4 @@
       "CORS": "*",
       "CORSCredentials": false
     }
-  }
+  }

code/create_app.py

@@ -9,12 +9,13 @@
 from os import path
 import sys
 import re
+from urllib.parse import quote
+
 import requests
 from openai import AzureOpenAI, Stream, APIStatusError
 from openai.types.chat import ChatCompletionChunk
 from flask import Flask, Response, request, Request, jsonify
 from dotenv import load_dotenv
-from urllib.parse import quote, urlparse
 from backend.batch.utilities.helpers.env_helper import EnvHelper
 from backend.batch.utilities.helpers.azure_search_helper import AzureSearchHelper
 from backend.batch.utilities.helpers.orchestrator_helper import Orchestrator

code/tests/chat_history/test_postgresdbservice.py

@@ -39,7 +39,7 @@ async def test_connect(mock_credential, mock_connect, postgres_client, mock_conn
         database="test_db",
         password="mock_token",
         port=5432,
-        ssl="require",
+        ssl=True,
     )
     assert postgres_client.conn == mock_connection
 

code/tests/functional/tests/functions/integrated_vectorization/test_integrated_vectorization_resource_creation.py

@@ -102,6 +102,10 @@ def test_integrated_vectorization_datasouce_created(
                 "container": {
                     "name": f"{app_config.get_from_json('AZURE_BLOB_STORAGE_INFO','containerName')}"
                 },
+                "identity": {
+                    "@odata.type": "#Microsoft.Azure.Search.DataUserAssignedIdentity",
+                    "userAssignedIdentity": ""
+                },
                 "dataDeletionDetectionPolicy": {
                     "@odata.type": "#Microsoft.Azure.Search.NativeBlobSoftDeleteDeletionDetectionPolicy"
                 },
@@ -367,6 +371,10 @@ def test_integrated_vectorization_skillset_created(
                         "resourceUri": f"https://localhost:{httpserver.port}/",
                         "deploymentId": f"{app_config.get_from_json('AZURE_OPENAI_EMBEDDING_MODEL_INFO','model')}",
                         "apiKey": f"{app_config.get('AZURE_OPENAI_API_KEY')}",
+                        "authIdentity": {
+                            "@odata.type": "#Microsoft.Azure.Search.DataUserAssignedIdentity",
+                            "userAssignedIdentity": ""
+                        },
                     },
                 ],
                 "indexProjections": {

code/tests/test_app.py

@@ -4,6 +4,7 @@
 
 from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
+from azure.core.exceptions import ClientAuthenticationError, ResourceNotFoundError, ServiceRequestError
 from openai import RateLimitError, BadRequestError, InternalServerError
 import pytest
 from flask.testing import FlaskClient
@@ -923,3 +924,228 @@ def test_conversation_azure_byod_returns_correct_response_when_streaming_without
             data
             == '{"id": "response.id", "model": "mock-openai-model", "created": 0, "object": "response.object", "choices": [{"messages": [{"role": "assistant", "content": "mock content"}]}]}\n'
         )
+
+
+class TestGetFile:
+    """Test the get_file endpoint for downloading files from blob storage."""
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_success(self, mock_blob_client_class, client):
+        """Test successful file download with proper headers."""
+        # given
+        filename = "test_document.pdf"
+        file_content = b"Mock file content for PDF document"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.return_value = True
+        mock_blob_client.download_file.return_value = file_content
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 200
+        assert response.data == file_content
+        assert response.headers["Content-Type"] == "application/pdf"
+        assert response.headers["Content-Disposition"] == f'inline; filename="{filename}"'
+        assert response.headers["Content-Length"] == str(len(file_content))
+        assert response.headers["Cache-Control"] == "public, max-age=3600"
+        assert response.headers["X-Content-Type-Options"] == "nosniff"
+        assert response.headers["X-Frame-Options"] == "DENY"
+        assert response.headers["Content-Security-Policy"] == "default-src 'none'"
+
+        # Verify blob client was initialized with correct container
+        mock_blob_client_class.assert_called_once_with(container_name="documents")
+        mock_blob_client.file_exists.assert_called_once_with(filename)
+        mock_blob_client.download_file.assert_called_once_with(filename)
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_with_unknown_mime_type(self, mock_blob_client_class, client):
+        """Test file download with unknown file extension."""
+        # given
+        filename = "test_file.unknownext"
+        file_content = b"Mock file content"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.return_value = True
+        mock_blob_client.download_file.return_value = file_content
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 200
+        assert response.headers["Content-Type"] == "application/octet-stream"
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_large_file_warning(self, mock_blob_client_class, client):
+        """Test that large files are handled properly with logging."""
+        # given
+        filename = "large_document.pdf"
+        file_content = b"x" * (11 * 1024 * 1024)  # 11MB file
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.return_value = True
+        mock_blob_client.download_file.return_value = file_content
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 200
+        assert len(response.data) == len(file_content)
+
+    def test_get_file_empty_filename(self, client):
+        """Test error response when filename is empty."""
+        # when
+        response = client.get("/api/files/")
+
+        # then
+        # This should result in a 404 as the route won't match
+        assert response.status_code == 404
+
+    def test_get_file_invalid_filename_too_long(self, client):
+        """Test error response for filenames that are too long."""
+        # given
+        filename = "a" * 256  # 256 characters, exceeds 255 limit
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 400
+        assert response.json == {"error": "Filename too long"}
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_not_exists_in_storage(self, mock_blob_client_class, client):
+        """Test error response when file doesn't exist in blob storage."""
+        # given
+        filename = "nonexistent.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.return_value = False
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 404
+        assert response.json == {"error": "File not found"}
+        mock_blob_client.file_exists.assert_called_once_with(filename)
+        mock_blob_client.download_file.assert_not_called()
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_client_authentication_error(self, mock_blob_client_class, client):
+        """Test handling of Azure ClientAuthenticationError."""
+        # given
+        filename = "test.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.side_effect = ClientAuthenticationError("Auth failed")
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 401
+        assert response.json == {"error": "Authentication failed"}
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_resource_not_found_error(self, mock_blob_client_class, client):
+        """Test handling of Azure ResourceNotFoundError."""
+        # given
+        filename = "test.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.side_effect = ResourceNotFoundError("Resource not found")
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 404
+        assert response.json == {"error": "File not found"}
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_service_request_error(self, mock_blob_client_class, client):
+        """Test handling of Azure ServiceRequestError."""
+        # given
+        filename = "test.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.side_effect = ServiceRequestError("Service unavailable")
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 503
+        assert response.json == {"error": "Storage service unavailable"}
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_unexpected_exception(self, mock_blob_client_class, client):
+        """Test handling of unexpected exceptions."""
+        # given
+        filename = "test.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.side_effect = Exception("Unexpected error")
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 500
+        assert response.json == {"error": "Internal server error"}
+
+    @patch("create_app.AzureBlobStorageClient")
+    def test_get_file_download_exception(self, mock_blob_client_class, client):
+        """Test handling of exceptions during file download."""
+        # given
+        filename = "test.pdf"
+
+        mock_blob_client = MagicMock()
+        mock_blob_client_class.return_value = mock_blob_client
+        mock_blob_client.file_exists.return_value = True
+        mock_blob_client.download_file.side_effect = Exception("Download failed")
+
+        # when
+        response = client.get(f"/api/files/{filename}")
+
+        # then
+        assert response.status_code == 500
+        assert response.json == {"error": "Internal server error"}
+
+    def test_get_file_valid_filenames(self, client):
+        """Test that valid filenames with allowed characters pass validation."""
+        # Mock the blob client to avoid actual Azure calls
+        with patch("create_app.AzureBlobStorageClient") as mock_blob_client_class:
+            mock_blob_client = MagicMock()
+            mock_blob_client_class.return_value = mock_blob_client
+            mock_blob_client.file_exists.return_value = True
+            mock_blob_client.download_file.return_value = b"test content"
+
+            valid_filenames = [
+                "document.pdf",
+                "file_name.txt",
+                "file-name.docx",
+                "file name.xlsx",
+                "test123.json",
+                "a.b",
+                "very_long_but_valid_filename_with_underscores.pdf"
+            ]
+
+            for filename in valid_filenames:
+                # when
+                response = client.get(f"/api/files/{filename}")
+
+                # then
+                assert response.status_code == 200, f"Failed for filename: {filename}"

code/tests/utilities/helpers/test_azure_postgres_helper.py

@@ -30,7 +30,7 @@ def test_create_search_client_success(self, mock_connect, mock_credential):
             "https://ossrdbms-aad.database.windows.net/.default"
         )
         mock_connect.assert_called_once_with(
-            "host=mock_host user=mock_user dbname=mock_database password=mock-access-token"
+            "host=mock_host user=mock_user dbname=mock_database password=mock-access-token sslmode=require"
         )
 
     @patch("backend.batch.utilities.helpers.azure_postgres_helper.psycopg2.connect")
@@ -92,7 +92,7 @@ def test_get_vector_store_success(self, mock_cursor, mock_connect, mock_credenti
         # Assert
         self.assertEqual(results, mock_results)
         mock_connect.assert_called_once_with(
-            "host=mock_host user=mock_user dbname=mock_database password=mock-access-token"
+            "host=mock_host user=mock_user dbname=mock_database password=mock-access-token sslmode=require"
         )
 
     @patch("backend.batch.utilities.helpers.azure_postgres_helper.get_azure_credential")

code/tests/utilities/helpers/test_azure_search_helper.py

@@ -90,6 +90,7 @@ def env_helper_mock():
         env_helper.AZURE_SEARCH_CONVERSATIONS_LOG_INDEX = (
             AZURE_SEARCH_CONVERSATIONS_LOG_INDEX
         )
+        env_helper.MANAGED_IDENTITY_CLIENT_ID = "mock-client-id"
 
         env_helper.USE_ADVANCED_IMAGE_PROCESSING = USE_ADVANCED_IMAGE_PROCESSING
         env_helper.is_auth_type_keys.return_value = True
@@ -156,7 +157,7 @@ def test_creates_search_clients_with_rabc(
     AzureSearchHelper()
 
     # then
-    default_azure_credential_mock.assert_called_once_with()
+    default_azure_credential_mock.assert_called_once_with("mock-client-id")
     search_client_mock.assert_called_once_with(
         endpoint=AZURE_SEARCH_SERVICE,
         index_name=AZURE_SEARCH_INDEX,

code/tests/utilities/helpers/test_secret_helper.py

@@ -25,6 +25,7 @@ def test_get_secret_returns_value_from_secret_client_when_use_key_vault_is_true(
     secret_name = "MY_SECRET"
     expected_value = ""
     monkeypatch.setenv("USE_KEY_VAULT", "true")
+    monkeypatch.setenv("AZURE_KEY_VAULT_ENDPOINT", "https://test-vault.vault.azure.net/")
     secret_client.return_value.get_secret.return_value.value = expected_value
     secret_helper = SecretHelper()