kiba-core 0.5.3.dev46__tar.gz → 0.5.3.dev48__tar.gz

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev46
+Version: 0.5.3.dev48
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/core/api/middleware/exception_handling_middleware.py

@@ -12,9 +12,10 @@ from core.exceptions import RedirectException
 
 
 class ExceptionHandlingMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app: ASGIApp, shouldSquashClientExceptions: bool = True) -> None:
+    def __init__(self, app: ASGIApp, shouldSquashClientExceptions: bool = True, shouldHideInternalErrors: bool = True) -> None:
         super().__init__(app=app)
         self.shouldSquashClientExceptions = shouldSquashClientExceptions
+        self.shouldHideInternalErrors = shouldHideInternalErrors
 
     @staticmethod
     def _convert_exception(exception: KibaException) -> Response:
@@ -38,8 +39,13 @@ class ExceptionHandlingMiddleware(BaseHTTPMiddleware):
             response = self._convert_exception(exception=exception)
         except KibaException as exception:
             logging.exception(exception)
+            if self.shouldHideInternalErrors:
+                exception = KibaException(message='Internal Server Error', statusCode=exception.statusCode, exceptionType=exception.exceptionType)
             response = self._convert_exception(exception=exception)
         except Exception as exception:  # noqa: BLE001
             logging.exception(exception)
-            response = self._convert_exception(exception=KibaException.from_exception(exception=exception))
+            kibaException = KibaException.from_exception(exception=exception)
+            if self.shouldHideInternalErrors:
+                kibaException = KibaException(message='Internal Server Error', statusCode=kibaException.statusCode)
+            response = self._convert_exception(exception=kibaException)
         return response

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/core/api/streaming_json_route.py

@@ -52,7 +52,7 @@ def streaming_json_route[ApiRequest: BaseModel, ApiResponse: BaseModel](
                 raise BadRequestException(f'Invalid request: {validationErrorMessage}')
             kibaRequest: KibaApiRequest[ApiRequest] = KibaApiRequest(scope=receivedRequest.scope, receive=receivedRequest._receive, send=receivedRequest._send)  # noqa: SLF001
             kibaRequest.data = requestParams
-            responseGeneratorOrAwaitable = func(kibaRequest)
+            responseGeneratorOrAwaitable = func(request=kibaRequest)
             responseGenerator = await responseGeneratorOrAwaitable if inspect.isawaitable(responseGeneratorOrAwaitable) else responseGeneratorOrAwaitable
             wrappedGenerator = _convert_to_json_generator(typing.cast(AsyncIterator[BaseModel], responseGenerator), expectedType=typing.cast(typing.Type[BaseModel], responseType))
             # NOTE(krishan711): we set content-encoding to identity to prevent gzip from trying to process it (cos it buffers all the content)

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/kiba_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiba-core
-Version: 0.5.3.dev46
+Version: 0.5.3.dev48
 Summary: Kiba Labs' python utilities
 Project-URL: repository, https://github.com/kibalabs/core-py
 Requires-Python: <4,>=3.12

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/kiba_core.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ kiba_core.egg-info/dependency_links.txt
 kiba_core.egg-info/requires.txt
 kiba_core.egg-info/top_level.txt
 tests/__init__.py
+tests/api/test_authorizer.py
 tests/api/test_json_route.py
 tests/api/test_streaming_json_route.py
 tests/caching/test_dict_cache.py

{kiba_core-0.5.3.dev46 → kiba_core-0.5.3.dev48}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiba-core"
-version = "0.5.3.dev46"
+version = "0.5.3.dev48"
 description = "Kiba Labs' python utilities"
 readme = "README.md"
 requires-python = ">=3.12, <4"

kiba_core-0.5.3.dev48/tests/api/test_authorizer.py

@@ -0,0 +1,154 @@
+import pytest
+from collections.abc import AsyncIterator
+from pydantic import BaseModel
+from starlette.applications import Starlette
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+from core.api.api_request import KibaApiRequest
+from core.api.authorizer import Authorizer, authorize_bearer_jwt
+from core.api.json_route import json_route
+from core.api.middleware.exception_handling_middleware import ExceptionHandlingMiddleware
+from core.api.streaming_json_route import streaming_json_route
+from core.exceptions import ForbiddenException
+from core.http.jwt import Jwt
+
+
+VALID_TOKEN = 'valid-token'
+VALID_USER_ID = 'user-123'
+
+
+class MockAuthorizer(Authorizer):
+    async def validate_jwt(self, jwtString: str) -> Jwt:
+        if jwtString != VALID_TOKEN:
+            raise ForbiddenException('Invalid token')
+        jwt = Jwt(payloadDict={'sub': VALID_USER_ID})
+        jwt.userId = VALID_USER_ID  # type: ignore[attr-defined]
+        return jwt
+
+
+class SimpleRequest(BaseModel):
+    value: str
+
+
+class SimpleResponse(BaseModel):
+    result: str
+    user_id: str | None = None
+
+
+authorizer = MockAuthorizer()
+
+
+@pytest.fixture
+def json_client():
+    @json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    @authorize_bearer_jwt(authorizer=authorizer)
+    async def protected_endpoint(request: KibaApiRequest[SimpleRequest]) -> SimpleResponse:
+        jwt = request.authJwt
+        return SimpleResponse(result=request.data.value, user_id=getattr(jwt, 'userId', None))
+
+    app = Starlette(routes=[Route('/protected', protected_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
+@pytest.fixture
+def streaming_client():
+    @streaming_json_route(requestType=SimpleRequest, responseType=SimpleResponse)
+    @authorize_bearer_jwt(authorizer=authorizer)
+    async def protected_streaming_endpoint(request: KibaApiRequest[SimpleRequest]) -> AsyncIterator[SimpleResponse]:
+        jwt = request.authJwt
+        yield SimpleResponse(result=request.data.value, user_id=getattr(jwt, 'userId', None))
+
+    app = Starlette(routes=[Route('/protected-stream', protected_streaming_endpoint, methods=['POST'])])
+    app.add_middleware(ExceptionHandlingMiddleware)
+    return TestClient(app, raise_server_exceptions=False)
+
+
+# --- json_route + authorize_bearer_jwt ---
+
+def test_json_no_auth_header_returns_403(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'})
+    assert response.status_code == 403
+
+
+def test_json_malformed_auth_header_not_bearer_returns_403(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'}, headers={'Authorization': 'Basic some-creds'})
+    assert response.status_code == 403
+
+
+def test_json_bearer_with_no_token_returns_403(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'}, headers={'Authorization': 'Bearer '})
+    assert response.status_code == 403
+
+
+def test_json_invalid_token_returns_403(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'}, headers={'Authorization': 'Bearer bad-token'})
+    assert response.status_code == 403
+
+
+def test_json_valid_token_returns_200(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 200
+    assert response.json()['result'] == 'hello'
+
+
+def test_json_valid_token_sets_auth_jwt_on_request(json_client):
+    response = json_client.post('/protected', json={'value': 'hello'}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 200
+    assert response.json()['user_id'] == VALID_USER_ID
+
+
+def test_json_missing_request_body_field_returns_400(json_client):
+    response = json_client.post('/protected', json={}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 400
+
+
+# --- streaming_json_route + authorize_bearer_jwt ---
+
+def test_streaming_no_auth_header_returns_403(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'})
+    assert response.status_code == 403
+
+
+def test_streaming_malformed_auth_header_not_bearer_returns_403(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': 'Basic some-creds'})
+    assert response.status_code == 403
+
+
+def test_streaming_bearer_with_no_token_returns_403(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': 'Bearer '})
+    assert response.status_code == 403
+
+
+def test_streaming_invalid_token_returns_403(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': 'Bearer bad-token'})
+    assert response.status_code == 403
+
+
+def test_streaming_valid_token_returns_200(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 200
+
+
+def test_streaming_valid_token_streams_correct_data(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 200
+    import json
+    lines = [l for l in response.content.decode().strip().split('\n') if l]
+    assert len(lines) == 1
+    data = json.loads(lines[0])
+    assert data['result'] == 'hello'
+
+
+def test_streaming_valid_token_sets_auth_jwt_on_request(streaming_client):
+    response = streaming_client.post('/protected-stream', json={'value': 'hello'}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 200
+    import json
+    data = json.loads(response.content.decode().strip())
+    assert data['user_id'] == VALID_USER_ID
+
+
+def test_streaming_missing_request_body_field_returns_400(streaming_client):
+    response = streaming_client.post('/protected-stream', json={}, headers={'Authorization': f'Bearer {VALID_TOKEN}'})
+    assert response.status_code == 400