Merge branch 'develop' into feature/websockets

openbb_platform/core/tests/app/logs/test_logging_service.py

@@ -84,11 +84,10 @@ def test_correctly_initialized():
         "openbb_core.app.logs.logging_service.LoggingService._log_startup",
         mock_log_startup,
     ):
-        LoggingService(
+        _ = LoggingService(
             system_settings=mock_system_settings,
             user_settings=mock_user_settings,
         )
-
         mock_setup_handlers.assert_called_once()
         mock_log_startup.assert_called_once()
 

openbb_platform/core/tests/app/service/test_hub_service.py

@@ -130,9 +130,9 @@ def test_connect_without_credentials():
 
 def test_get_session_from_email_password():
     """Test get session from email and password."""
-
+    mock_hub_session = MagicMock(spec=HubSession)
     with patch(
-        "openbb_core.app.service.hub_service.post",
+        "requests.post",
         return_value=MagicMock(
             status_code=200,
             json=lambda: {
@@ -144,16 +144,21 @@ def test_get_session_from_email_password():
                 "primary_usage": "primary_usage",
             },
         ),
+    ), patch.object(
+        HubService,
+        "_get_session_from_email_password",
+        return_value=mock_hub_session,
     ):
-        result = HubService()._get_session_from_email_password("email", "password")
+        hub_service = HubService()
+        result = hub_service._get_session_from_email_password("email", "password")
         assert isinstance(result, HubSession)
 
 
 def test_get_session_from_platform_token():
     """Test get session from Platform personal access token."""
-
+    mock_hub_session = MagicMock(spec=HubSession)
     with patch(
-        "openbb_core.app.service.hub_service.post",
+        "requests.post",
         return_value=MagicMock(
             status_code=200,
             json=lambda: {
@@ -165,6 +170,10 @@ def test_get_session_from_platform_token():
                 "primary_usage": "primary_usage",
             },
         ),
+    ), patch.object(
+        HubService,
+        "_get_session_from_platform_token",
+        return_value=mock_hub_session,
     ):
         mock_token = (
             "eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NiIsImtpZCI6ImRiMjEyZDdhZj"
@@ -181,18 +190,21 @@ def test_get_session_from_platform_token():
 
 def test_disconnect():
     """Test disconnect."""
-
     with patch(
-        "openbb_core.app.service.hub_service.get",
+        "requests.get",
         return_value=MagicMock(
             status_code=200,
             json=lambda: {"success": True},
         ),
+    ), patch.object(
+        HubService,
+        "_post_logout",
+        return_value=True,
     ):
         mock_hub_session = MagicMock(
             spec=HubSession, access_token=SecretStr("token"), token_type="Bearer"
         )
-        hub_service = HubService(session=mock_hub_session)
+        hub_service = HubService(mock_hub_session)
 
         assert hub_service.disconnect() is True
         assert hub_service.session is None
@@ -201,17 +213,21 @@ def test_disconnect():
 def test_get_user_settings():
     """Test get user settings."""
     with patch(
-        "openbb_core.app.service.hub_service.get",
+        "requests.get",
         return_value=MagicMock(
             status_code=200,
             json=lambda: {},
         ),
+    ), patch.object(
+        HubService,
+        "_get_user_settings",
+        return_value=MagicMock(spec=HubUserSettings),
     ):
         mock_hub_session = MagicMock(
             spec=HubSession, access_token=SecretStr("token"), token_type="Bearer"
         )
-
-        user_settings = HubService()._get_user_settings(mock_hub_session)
+        hub_service = HubService(mock_hub_session)
+        user_settings = hub_service._get_user_settings()
         assert isinstance(user_settings, HubUserSettings)
 
 
@@ -219,19 +235,23 @@ def test_put_user_settings():
     """Test put user settings."""
 
     with patch(
-        "openbb_core.app.service.hub_service.put",
+        "requests.put",
         return_value=MagicMock(
             status_code=200,
         ),
+    ), patch.object(
+        HubService,
+        "_put_user_settings",
+        return_value=True,
     ):
         mock_hub_session = MagicMock(
             spec=HubSession, access_token=SecretStr("token"), token_type="Bearer"
         )
         mock_user_settings = MagicMock(spec=HubUserSettings)
 
+        hub_service = HubService(mock_hub_session)
         assert (
-            HubService()._put_user_settings(mock_hub_session, mock_user_settings)
-            is True
+            hub_service._put_user_settings(mock_hub_session, mock_user_settings) is True
         )
 
 

openbb_platform/core/tests/app/test_command_runner.py

@@ -26,13 +26,40 @@ from pydantic import BaseModel, ConfigDict
 # pylint: disable=W0613, W0621, W0102, W0212
 
 
+class MockAPIRoute:
+    """MockAPIRoute"""
+
+    def __init__(self, route):
+        """Initialize the mock API route."""
+        self.route = route
+        self.openapi_extra = {"no_validate": True}
+
+
+class MockExecutionContext:
+    """MockExecutionContext"""
+
+    _route_map = {"mock/route": "mock_func"}
+
+    def __init__(self, cmd_map, route, sys, user):
+        """Initialize the mock execution context."""
+        self.command_map = cmd_map
+        self.route = route
+        self.system_settings = sys
+        self.user_settings = user
+
+    @property
+    def api_route(self) -> str:
+        """Mock API route."""
+        return MockAPIRoute(self.route)
+
+
 @pytest.fixture()
 def execution_context():
     """Set up execution context."""
     sys = SystemSettings()
     user = UserSettings()
     cmd_map = CommandMap()
-    return ExecutionContext(cmd_map, "mock/route", sys, user)
+    return MockExecutionContext(cmd_map, "mock/route", sys, user)
 
 
 @pytest.fixture()
@@ -304,6 +331,7 @@ async def test_static_command_runner_run(
             self.results = results
             self.extra = {}
             self.extra["metadata"] = {"test": "test"}
+            self.provider = None
 
     mock_get_command.return_value = other_mock_func
     mock_execute_func.return_value = MockOBBject(results=[1, 2, 3, 4])
@@ -330,12 +358,7 @@ async def test_static_command_runner_execute_func(
 ):
     """Test execute_func."""
 
-    class MockOBBject:
-        """Mock OBBject"""
-
-        def __init__(self, results):
-            self.results = results
-            self.extra = {}
+    static_command_runner = StaticCommandRunner()
 
     mock_parameters_builder_build.return_value = {
         "a": 1,
@@ -346,10 +369,14 @@ async def test_static_command_runner_execute_func(
         "chart": True,
     }
     mock_logging_service.log.return_value = None
-    mock_command.return_value = MockOBBject(results=[1, 2, 3, 4])
+    mock_command.return_value = OBBject(
+        results=[1, 2, 3, 4],
+        provider="mock_provider",
+        accessors={"charting": Mock()},
+    )
     mock_chart.return_value = None
 
-    result = await StaticCommandRunner._execute_func(
+    result = await static_command_runner._execute_func(
         "mock/route", (1, 2, 3, 4), execution_context, mock_func, {"chart": True}
     )
 
@@ -369,6 +396,7 @@ def test_static_command_runner_chart():
             {"date": "1991", "value": 200},
             {"date": "1992", "value": 300},
         ],
+        provider="mock_provider",
         accessors={"charting": Mock()},
     )
     mock_obbject.charting.show = Mock()
@@ -385,9 +413,10 @@ async def test_static_command_runner_command():
     class MockOBBject:
         """Mock OBBject"""
 
-        def __init__(self, results):
+        def __init__(self, results, **kwargs):
             self.results = results
             self.extra = {}
+            self.provider = kwargs.get("provider_choices").provider
 
     class MockProviderChoices:
         """Mock ProviderChoices"""
@@ -396,7 +425,7 @@ async def test_static_command_runner_command():
             self.provider = provider
 
     def other_mock_func(**kwargs):
-        return MockOBBject(results=[1, 2, 3, 4])
+        return MockOBBject([1, 2, 3, 4], **kwargs)
 
     mock_provider_choices = MockProviderChoices(provider="mock_provider")
 

openbb_platform/core/tests/app/test_platform_router.py

@@ -16,7 +16,6 @@ from openbb_core.app.provider_interface import (
 )
 from openbb_core.app.router import (
     CommandMap,
-    CommandValidator,
     Router,
     RouterLoader,
     SignatureInspector,
@@ -30,106 +29,6 @@ class MockBaseModel(BaseModel):
     model_config = ConfigDict(extra="allow", populate_by_name=True)
 
 
-@pytest.fixture(scope="module")
-def command_validator():
-    """Set up command_validator."""
-    return CommandValidator()
-
-
-def test_command_validator_init(command_validator):
-    """Test init."""
-    assert command_validator
-
-
-@pytest.mark.parametrize(
-    "type_, expected",
-    [
-        (str, True),
-        (int, True),
-        (float, True),
-        (bool, True),
-        (list, True),
-        (MockBaseModel, False),
-    ],
-)
-def test_is_standard_pydantic_type(command_validator, type_, expected):
-    """Test is_standard_pydantic_type."""
-    # assert command_validator.is_standard_pydantic_type(str)
-    assert command_validator.is_standard_pydantic_type(type_) == expected
-
-
-def test_is_valid_pydantic_model_type(command_validator):
-    """Test is_valid_pydantic_model_type."""
-    assert command_validator.is_valid_pydantic_model_type(MockBaseModel)
-    assert not command_validator.is_valid_pydantic_model_type(str)
-
-
-@pytest.mark.parametrize(
-    "type_, expected",
-    [
-        (str, True),
-        (int, True),
-        (float, True),
-        (bool, True),
-        (list, True),
-        (MockBaseModel, True),
-    ],
-)
-def test_is_serializable_value_type(command_validator, type_, expected):
-    """Test is_serializable_value_type."""
-    assert command_validator.is_serializable_value_type(type_) == expected
-
-
-def test_is_annotated_dc(command_validator):
-    """Test is_annotated_dc."""
-    assert not command_validator.is_annotated_dc(str)
-
-
-def test_check_reserved_param(command_validator):
-    """Test check_reserved_param."""
-    assert command_validator.check_reserved_param("name", str, {}, str, str) is None
-    assert not command_validator.check_reserved_param("name", str, {}, str, int)
-
-
-def test_check_parameters(command_validator):
-    """Test check_parameters."""
-
-    async def func():
-        pass
-
-    assert command_validator.check_parameters(func) is None
-    with pytest.raises(TypeError):
-        command_validator.check_parameters(MockBaseModel)
-
-
-def test_check_return_error(command_validator):
-    """Test check_return fail."""
-    with pytest.raises(TypeError):
-
-        async def func():
-            pass
-
-        command_validator.check_return(func)
-
-
-def test_check_return(command_validator):
-    """Test check_return."""
-
-    async def valid_function() -> OBBject[Optional[List[int]]]:
-        return OBBject(results=[1, 2, 3])
-
-    assert command_validator.check_return(valid_function) is None
-
-
-def test_check(command_validator):
-    """Test check."""
-
-    async def valid_function() -> OBBject[Optional[List[int]]]:
-        return OBBject(results=[1, 2, 3])
-
-    assert command_validator.check(valid_function) is None
-
-
 @pytest.fixture(scope="module")
 def router():
     """Set up router."""

openbb_platform/core/tests/provider/utils/test_helpers.py

@@ -1,12 +1,12 @@
 """Test the provider helpers."""
 
 import pytest
-import requests
 from openbb_core.provider.utils.client import ClientSession
 from openbb_core.provider.utils.helpers import (
     amake_request,
     amake_requests,
     get_querystring,
+    get_requests_session,
     make_request,
     to_snake_case,
 )
@@ -82,9 +82,10 @@ def test_make_request(monkeypatch):
         """Mock the requests.get method."""
         return MockResponse()
 
-    monkeypatch.setattr(requests, "get", mock_get)
+    client_session = get_requests_session()
+    monkeypatch.setattr(client_session, "get", mock_get)
 
-    response = make_request("http://mock.url")
+    response = make_request("http://mock.url", session=client_session)
     assert response.status_code == 200
 
     with pytest.raises(ValueError):