dapr-ext-fastapi-dev 1.9.0rc1.dev1402__tar.gz → 1.16.0.dev59__tar.gz

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.4
 Name: dapr-ext-fastapi-dev
-Version: 1.9.0rc1.dev1402
+Version: 1.16.0.dev59
 Summary: The developmental release for Dapr FastAPI extension.
 Home-page: https://dapr.io/
 Author: Dapr Authors
@@ -8,15 +8,23 @@ Author-email: daprweb@microsoft.com
 License: Apache
 Project-URL: Documentation, https://github.com/dapr/docs
 Project-URL: Source, https://github.com/dapr/python-sdk
-Description: This is the developmental release for Dapr FastAPI extension.
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: dapr>=1.16.0.dev
+Requires-Dist: uvicorn>=0.11.6
+Requires-Dist: fastapi>=0.60.1
+Dynamic: description
+Dynamic: license-file
+Dynamic: summary
+
+This is the developmental release for Dapr FastAPI extension.

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr/ext/fastapi/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Copyright 2021 The Dapr Authors
+Copyright 2023 The Dapr Authors
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -16,8 +16,4 @@ limitations under the License.
 from .actor import DaprActor
 from .app import DaprApp
 
-
-__all__ = [
-    'DaprActor',
-    'DaprApp'
-]
+__all__ = ['DaprActor', 'DaprApp']

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr/ext/fastapi/actor.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Copyright 2021 The Dapr Authors
+Copyright 2023 The Dapr Authors
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -13,25 +13,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Any, Optional, Type, List
-
-from fastapi import FastAPI, APIRouter, Request, Response, status   # type: ignore
-from fastapi.logger import logger
-from fastapi.responses import JSONResponse
+from typing import Any, List, Optional, Type
 
 from dapr.actor import Actor, ActorRuntime
-from dapr.clients.exceptions import DaprInternalError, ERROR_CODE_UNKNOWN
+from dapr.clients.exceptions import ERROR_CODE_UNKNOWN, DaprInternalError
 from dapr.serializers import DefaultJSONSerializer
+from fastapi import APIRouter, FastAPI, Request, Response, status  # type: ignore
+from fastapi.logger import logger
+from fastapi.responses import JSONResponse
 
-DEFAULT_CONTENT_TYPE = "application/json; utf-8"
+DEFAULT_CONTENT_TYPE = 'application/json; utf-8'
 DAPR_REENTRANCY_ID_HEADER = 'Dapr-Reentrancy-Id'
 
 
 def _wrap_response(
-        status_code: int,
-        msg: Any,
-        error_code: Optional[str] = None,
-        content_type: Optional[str] = DEFAULT_CONTENT_TYPE):
+    status_code: int,
+    msg: Any,
+    error_code: Optional[str] = None,
+    content_type: Optional[str] = DEFAULT_CONTENT_TYPE,
+):
     resp = None
     if isinstance(msg, str):
         response_obj = {
@@ -48,9 +48,7 @@ def _wrap_response(
 
 
 class DaprActor(object):
-
-    def __init__(self, app: FastAPI,
-                 router_tags: Optional[List[str]] = ['Actor']):
+    def __init__(self, app: FastAPI, router_tags: Optional[List[str]] = ['Actor']):
         # router_tags should be added to all magic Dapr Actor methods implemented here
         self._router_tags = router_tags
         self._router = APIRouter()
@@ -59,7 +57,7 @@ class DaprActor(object):
         app.include_router(self._router)
 
     def init_routes(self, router: APIRouter):
-        @router.get("/healthz", tags=self._router_tags)
+        @router.get('/healthz', tags=self._router_tags)
         async def healthz():
             return {'status': 'ok'}
 
@@ -73,96 +71,83 @@ class DaprActor(object):
             try:
                 await ActorRuntime.deactivate(actor_type_name, actor_id)
             except DaprInternalError as ex:
-                return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    ex.as_dict())
+                return _wrap_response(status.HTTP_500_INTERNAL_SERVER_ERROR, ex.as_json_safe_dict())
             except Exception as ex:
                 return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    repr(ex),
-                    ERROR_CODE_UNKNOWN)
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN
+                )
 
             msg = f'deactivated actor: {actor_type_name}.{actor_id}'
             logger.debug(msg)
             return _wrap_response(status.HTTP_200_OK, msg)
 
-        @router.put('/actors/{actor_type_name}/{actor_id}/method/{method_name}',
-                    tags=self._router_tags)
+        @router.put(
+            '/actors/{actor_type_name}/{actor_id}/method/{method_name}', tags=self._router_tags
+        )
         async def actor_method(
-                actor_type_name: str,
-                actor_id: str,
-                method_name: str,
-                request: Request):
+            actor_type_name: str, actor_id: str, method_name: str, request: Request
+        ):
             try:
                 # Read raw bytes from request stream
                 req_body = await request.body()
                 reentrancy_id = request.headers.get(DAPR_REENTRANCY_ID_HEADER)
                 result = await ActorRuntime.dispatch(
-                    actor_type_name, actor_id, method_name, req_body, reentrancy_id)
+                    actor_type_name, actor_id, method_name, req_body, reentrancy_id
+                )
             except DaprInternalError as ex:
-                return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR, ex.as_dict())
+                return _wrap_response(status.HTTP_500_INTERNAL_SERVER_ERROR, ex.as_json_safe_dict())
             except Exception as ex:
                 return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    repr(ex),
-                    ERROR_CODE_UNKNOWN)
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN
+                )
 
             msg = f'called method. actor: {actor_type_name}.{actor_id}, method: {method_name}'
             logger.debug(msg)
             return _wrap_response(status.HTTP_200_OK, result)
 
-        @router.put('/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}',
-                    tags=self._router_tags)
+        @router.put(
+            '/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}', tags=self._router_tags
+        )
         async def actor_timer(
-                actor_type_name: str,
-                actor_id: str,
-                timer_name: str,
-                request: Request):
+            actor_type_name: str, actor_id: str, timer_name: str, request: Request
+        ):
             try:
                 # Read raw bytes from request stream
                 req_body = await request.body()
                 await ActorRuntime.fire_timer(actor_type_name, actor_id, timer_name, req_body)
             except DaprInternalError as ex:
-                return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    ex.as_dict())
+                return _wrap_response(status.HTTP_500_INTERNAL_SERVER_ERROR, ex.as_json_safe_dict())
             except Exception as ex:
                 return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    repr(ex),
-                    ERROR_CODE_UNKNOWN)
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN
+                )
 
             msg = f'called timer. actor: {actor_type_name}.{actor_id}, timer: {timer_name}'
             logger.debug(msg)
             return _wrap_response(status.HTTP_200_OK, msg)
 
-        @router.put('/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}',
-                    tags=self._router_tags)
+        @router.put(
+            '/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}',
+            tags=self._router_tags,
+        )
         async def actor_reminder(
-                actor_type_name: str,
-                actor_id: str,
-                reminder_name: str,
-                request: Request):
+            actor_type_name: str, actor_id: str, reminder_name: str, request: Request
+        ):
             try:
                 # Read raw bytes from request stream
                 req_body = await request.body()
-                await ActorRuntime.fire_reminder(
-                    actor_type_name, actor_id, reminder_name, req_body)
+                await ActorRuntime.fire_reminder(actor_type_name, actor_id, reminder_name, req_body)
             except DaprInternalError as ex:
-                return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    ex.as_dict())
+                return _wrap_response(status.HTTP_500_INTERNAL_SERVER_ERROR, ex.as_json_safe_dict())
             except Exception as ex:
                 return _wrap_response(
-                    status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    repr(ex),
-                    ERROR_CODE_UNKNOWN)
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, repr(ex), ERROR_CODE_UNKNOWN
+                )
 
             msg = f'called reminder. actor: {actor_type_name}.{actor_id}, reminder: {reminder_name}'
             logger.debug(msg)
             return _wrap_response(status.HTTP_200_OK, msg)
 
-    async def register_actor(self, actor: Type[Actor]) -> None:
-        await ActorRuntime.register_actor(actor)
+    async def register_actor(self, actor: Type[Actor], **kwargs) -> None:
+        await ActorRuntime.register_actor(actor, **kwargs)
         logger.debug(f'registered actor: {actor.__class__.__name__}')

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr/ext/fastapi/app.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-Copyright 2021 The Dapr Authors
+Copyright 2023 The Dapr Authors
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -13,6 +13,7 @@ limitations under the License.
 """
 
 from typing import Dict, List, Optional
+
 from fastapi import FastAPI  # type: ignore
 
 
@@ -24,24 +25,24 @@ class DaprApp:
         app_instance: The FastAPI instance to wrap.
     """
 
-    def __init__(self, app_instance: FastAPI,
-                 router_tags: Optional[List[str]] = ['PubSub']):
+    def __init__(self, app_instance: FastAPI, router_tags: Optional[List[str]] = ['PubSub']):
         # The router_tags should be added to all magic Dapr App PubSub methods implemented here
         self._router_tags = router_tags
         self._app = app_instance
         self._subscriptions: List[Dict[str, object]] = []
 
-        self._app.add_api_route("/dapr/subscribe",
-                                self._get_subscriptions,
-                                methods=["GET"],
-                                tags=self._router_tags)
-
-    def subscribe(self,
-                  pubsub: str,
-                  topic: str,
-                  metadata: Optional[Dict[str, str]] = {},
-                  route: Optional[str] = None,
-                  dead_letter_topic: Optional[str] = None):
+        self._app.add_api_route(
+            '/dapr/subscribe', self._get_subscriptions, methods=['GET'], tags=self._router_tags
+        )
+
+    def subscribe(
+        self,
+        pubsub: str,
+        topic: str,
+        metadata: Optional[Dict[str, str]] = {},
+        route: Optional[str] = None,
+        dead_letter_topic: Optional[str] = None,
+    ):
         """
         Subscribes to a topic on a pub/sub component.
 
@@ -73,21 +74,27 @@ class DaprApp:
         Returns:
             The decorator for the function.
         """
+
         def decorator(func):
-            event_handler_route = f"/events/{pubsub}/{topic}" if route is None else route
-
-            self._app.add_api_route(event_handler_route,
-                                    func,
-                                    methods=["POST"],
-                                    tags=self._router_tags)
-
-            self._subscriptions.append({
-                "pubsubname": pubsub,
-                "topic": topic,
-                "route": event_handler_route,
-                "metadata": metadata,
-                **({"deadLetterTopic": dead_letter_topic} if dead_letter_topic is not None else {})
-            })
+            event_handler_route = f'/events/{pubsub}/{topic}' if route is None else route
+
+            self._app.add_api_route(
+                event_handler_route, func, methods=['POST'], tags=self._router_tags
+            )
+
+            self._subscriptions.append(
+                {
+                    'pubsubname': pubsub,
+                    'topic': topic,
+                    'route': event_handler_route,
+                    'metadata': metadata,
+                    **(
+                        {'deadLetterTopic': dead_letter_topic}
+                        if dead_letter_topic is not None
+                        else {}
+                    ),
+                }
+            )
 
         return decorator
 

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr/ext/fastapi/version.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Copyright 2021 The Dapr Authors
+Copyright 2023 The Dapr Authors
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -13,4 +13,4 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-__version__ = "1.9.0rc1.dev"
+__version__ = '1.16.0.dev'

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr_ext_fastapi_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.4
 Name: dapr-ext-fastapi-dev
-Version: 1.9.0rc1.dev1402
+Version: 1.16.0.dev59
 Summary: The developmental release for Dapr FastAPI extension.
 Home-page: https://dapr.io/
 Author: Dapr Authors
@@ -8,15 +8,23 @@ Author-email: daprweb@microsoft.com
 License: Apache
 Project-URL: Documentation, https://github.com/dapr/docs
 Project-URL: Source, https://github.com/dapr/python-sdk
-Description: This is the developmental release for Dapr FastAPI extension.
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: dapr>=1.16.0.dev
+Requires-Dist: uvicorn>=0.11.6
+Requires-Dist: fastapi>=0.60.1
+Dynamic: description
+Dynamic: license-file
+Dynamic: summary
+
+This is the developmental release for Dapr FastAPI extension.

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr_ext_fastapi_dev.egg-info/SOURCES.txt

@@ -5,9 +5,12 @@ setup.py
 dapr/ext/fastapi/__init__.py
 dapr/ext/fastapi/actor.py
 dapr/ext/fastapi/app.py
+dapr/ext/fastapi/py.typed
 dapr/ext/fastapi/version.py
 dapr_ext_fastapi_dev.egg-info/PKG-INFO
 dapr_ext_fastapi_dev.egg-info/SOURCES.txt
 dapr_ext_fastapi_dev.egg-info/dependency_links.txt
 dapr_ext_fastapi_dev.egg-info/requires.txt
-dapr_ext_fastapi_dev.egg-info/top_level.txt
+dapr_ext_fastapi_dev.egg-info/top_level.txt
+tests/test_app.py
+tests/test_dapractor.py

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/dapr_ext_fastapi_dev.egg-info/requires.txt

@@ -1,3 +1,3 @@
-dapr-dev>=1.9.0rc1.dev
+dapr>=1.16.0.dev
 uvicorn>=0.11.6
 fastapi>=0.60.1

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/setup.cfg

@@ -10,20 +10,21 @@ classifiers =
 	License :: OSI Approved :: Apache Software License
 	Operating System :: OS Independent
 	Programming Language :: Python
-	Programming Language :: Python :: 3.7
-	Programming Language :: Python :: 3.8
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
 project_urls = 
 	Documentation = https://github.com/dapr/docs
 	Source = https://github.com/dapr/python-sdk
 
 [options]
-python_requires = >=3.7
+python_requires = >=3.9
 packages = find_namespace:
 include_package_data = True
 install_requires = 
-	dapr-dev >= 1.9.0rc1.dev
+	dapr >= 1.16.0.dev
 	uvicorn >= 0.11.6
 	fastapi >= 0.60.1
 
@@ -33,6 +34,10 @@ include =
 exclude = 
 	tests
 
+[options.package_data]
+dapr.ext.fastapi = 
+	py.typed
+
 [egg_info]
 tag_build = 
 tag_date = 0

{dapr-ext-fastapi-dev-1.9.0rc1.dev1402 → dapr_ext_fastapi_dev-1.16.0.dev59}/setup.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Copyright 2021 The Dapr Authors
+Copyright 2023 The Dapr Authors
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -31,7 +31,7 @@ def is_release():
 name = 'dapr-ext-fastapi'
 version = __version__
 description = 'The official release of Dapr FastAPI extension.'
-long_description = '''
+long_description = """
 This is the FastAPI extension for Dapr.
 
 Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to
@@ -42,7 +42,7 @@ Dapr codifies the best practices for building microservice applications into ope
 independent, building blocks that enable you to build portable applications with the language
 and framework of your choice. Each building block is independent and you can use one, some,
 or all of them in your application.
-'''.lstrip()
+""".lstrip()
 
 # Get build number from GITHUB_RUN_NUMBER environment variable
 build_number = os.environ.get('GITHUB_RUN_NUMBER', '0')

dapr_ext_fastapi_dev-1.16.0.dev59/tests/test_app.py

@@ -0,0 +1,156 @@
+import unittest
+
+from dapr.ext.fastapi import DaprApp
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    body: str
+
+
+class DaprAppTest(unittest.TestCase):
+    def setUp(self):
+        self.app = FastAPI()
+        self.dapr_app = DaprApp(self.app)
+        self.client = TestClient(self.app)
+
+    def test_subscribe_subscription_registered(self):
+        @self.dapr_app.subscribe(pubsub='pubsub', topic='test')
+        def event_handler(event_data: Message):
+            return 'default route'
+
+        self.assertEqual(len(self.dapr_app._subscriptions), 1)
+
+        self.assertIn('/dapr/subscribe', [route.path for route in self.app.router.routes])
+        self.assertIn('/events/pubsub/test', [route.path for route in self.app.router.routes])
+
+        response = self.client.get('/dapr/subscribe')
+        self.assertEqual(
+            [
+                {
+                    'pubsubname': 'pubsub',
+                    'topic': 'test',
+                    'route': '/events/pubsub/test',
+                    'metadata': {},
+                }
+            ],
+            response.json(),
+        )
+
+        response = self.client.post('/events/pubsub/test', json={'body': 'new message'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, '"default route"')
+
+    def test_subscribe_with_route_subscription_registered_with_custom_route(self):
+        @self.dapr_app.subscribe(pubsub='pubsub', topic='test', route='/do-something')
+        def event_handler(event_data: Message):
+            return 'custom route'
+
+        self.assertEqual(len(self.dapr_app._subscriptions), 1)
+
+        self.assertIn('/dapr/subscribe', [route.path for route in self.app.router.routes])
+        self.assertIn('/do-something', [route.path for route in self.app.router.routes])
+
+        response = self.client.get('/dapr/subscribe')
+        self.assertEqual(
+            [{'pubsubname': 'pubsub', 'topic': 'test', 'route': '/do-something', 'metadata': {}}],
+            response.json(),
+        )
+
+        response = self.client.post('/do-something', json={'body': 'new message'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, '"custom route"')
+
+    def test_subscribe_metadata(self):
+        handler_metadata = {'rawPayload': 'true'}
+
+        @self.dapr_app.subscribe(pubsub='pubsub', topic='test', metadata=handler_metadata)
+        def event_handler(event_data: Message):
+            return 'custom metadata'
+
+        self.assertEqual((self.dapr_app._subscriptions[0]['metadata']['rawPayload']), 'true')
+
+        response = self.client.get('/dapr/subscribe')
+        self.assertEqual(
+            [
+                {
+                    'pubsubname': 'pubsub',
+                    'topic': 'test',
+                    'route': '/events/pubsub/test',
+                    'metadata': {'rawPayload': 'true'},
+                }
+            ],
+            response.json(),
+        )
+
+        response = self.client.post('/events/pubsub/test', json={'body': 'new message'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, '"custom metadata"')
+
+    def test_router_tag(self):
+        app1 = FastAPI()
+        app2 = FastAPI()
+        app3 = FastAPI()
+        DaprApp(app_instance=app1, router_tags=['MyTag', 'PubSub']).subscribe(
+            pubsub='mypubsub', topic='test'
+        )
+        DaprApp(app_instance=app2).subscribe(pubsub='mypubsub', topic='test')
+        DaprApp(app_instance=app3, router_tags=None).subscribe(pubsub='mypubsub', topic='test')
+
+        PATHS_WITH_EXPECTED_TAGS = ['/dapr/subscribe', '/events/mypubsub/test']
+
+        foundTags = False
+        for route in app1.router.routes:
+            if hasattr(route, 'tags'):
+                self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS)
+                self.assertEqual(['MyTag', 'PubSub'], route.tags)
+                foundTags = True
+        if not foundTags:
+            self.fail('No tags found')
+
+        foundTags = False
+        for route in app2.router.routes:
+            if hasattr(route, 'tags'):
+                self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS)
+                self.assertEqual(['PubSub'], route.tags)
+                foundTags = True
+        if not foundTags:
+            self.fail('No tags found')
+
+        for route in app3.router.routes:
+            if hasattr(route, 'tags'):
+                if len(route.tags) > 0:
+                    self.fail('Found tags on route that should not have any')
+
+    def test_subscribe_dead_letter(self):
+        dead_letter_topic = 'dead-test'
+
+        @self.dapr_app.subscribe(pubsub='pubsub', topic='test', dead_letter_topic=dead_letter_topic)
+        def event_handler(event_data: Message):
+            return 'dead letter test'
+
+        self.assertEqual((self.dapr_app._subscriptions[0]['deadLetterTopic']), dead_letter_topic)
+
+        response = self.client.get('/dapr/subscribe')
+        self.assertEqual(
+            [
+                {
+                    'pubsubname': 'pubsub',
+                    'topic': 'test',
+                    'route': '/events/pubsub/test',
+                    'metadata': {},
+                    'deadLetterTopic': dead_letter_topic,
+                }
+            ],
+            response.json(),
+        )
+
+        response = self.client.post('/events/pubsub/test', json={'body': 'new message'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.text, '"dead letter test"')
+
+
+if __name__ == '__main__':
+    unittest.main()

dapr_ext_fastapi_dev-1.16.0.dev59/tests/test_dapractor.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+"""
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+import unittest
+
+from dapr.ext.fastapi.actor import DaprActor, _wrap_response
+from fastapi import FastAPI
+
+
+class DaprActorTest(unittest.TestCase):
+    def test_wrap_response_str(self):
+        r = _wrap_response(200, 'fake_message')
+        self.assertEqual({'message': 'fake_message'}, json.loads(r.body))
+        self.assertEqual(200, r.status_code)
+
+    def test_wrap_response_str_err(self):
+        r = _wrap_response(400, 'fake_message', 'ERR_FAKE')
+        self.assertEqual({'message': 'fake_message', 'errorCode': 'ERR_FAKE'}, json.loads(r.body))
+        self.assertEqual(400, r.status_code)
+
+    def test_wrap_response_bytes_text(self):
+        r = _wrap_response(200, b'fake_bytes_message', content_type='text/plain')
+        self.assertEqual(b'fake_bytes_message', r.body)
+        self.assertEqual(200, r.status_code)
+        self.assertEqual('text/plain', r.media_type)
+
+    def test_wrap_response_obj(self):
+        fake_data = {'message': 'ok'}
+        r = _wrap_response(200, fake_data)
+        self.assertEqual(fake_data, json.loads(r.body))
+        self.assertEqual(200, r.status_code)
+
+    def test_router_tag(self):
+        app1 = FastAPI()
+        app2 = FastAPI()
+        app3 = FastAPI()
+        DaprActor(app=app1, router_tags=['MyTag', 'Actor'])
+        DaprActor(app=app2)
+        DaprActor(app=app3, router_tags=None)
+
+        PATHS_WITH_EXPECTED_TAGS = [
+            '/healthz',
+            '/dapr/config',
+            '/actors/{actor_type_name}/{actor_id}',
+            '/actors/{actor_type_name}/{actor_id}/method/{method_name}',
+            '/actors/{actor_type_name}/{actor_id}/method/timer/{timer_name}',
+            '/actors/{actor_type_name}/{actor_id}/method/remind/{reminder_name}',
+        ]
+
+        foundTags = False
+        for route in app1.router.routes:
+            if hasattr(route, 'tags'):
+                self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS)
+                self.assertEqual(['MyTag', 'Actor'], route.tags)
+                foundTags = True
+        if not foundTags:
+            self.fail('No tags found')
+
+        foundTags = False
+        for route in app2.router.routes:
+            if hasattr(route, 'tags'):
+                self.assertIn(route.path, PATHS_WITH_EXPECTED_TAGS)
+                self.assertEqual(['Actor'], route.tags)
+                foundTags = True
+        if not foundTags:
+            self.fail('No tags found')
+
+        for route in app3.router.routes:
+            if hasattr(route, 'tags'):
+                if len(route.tags) > 0:
+                    self.fail('Found tags on route that should not have any')
+
+
+if __name__ == '__main__':
+    unittest.main()