Move

openbb_sdk/sdk/core/tests/app/test_provider_interface.py

@@ -0,0 +1,100 @@
+"""Test provider interface."""
+# pylint: disable=redefined-outer-name
+
+import pytest
+from openbb_core.app.provider_interface import (
+    ProviderChoices,
+    ProviderInterface,
+    ProviderRegistry,
+    get_provider_interface,
+)
+
+
+@pytest.fixture(scope="module")
+def provider_interface():
+    """Set up provider_interface."""
+    return ProviderInterface()
+
+
+def test_init(provider_interface):
+    """Test init."""
+    assert provider_interface
+
+
+def test_get_provider_interface():
+    """Test get provider interface."""
+    assert isinstance(get_provider_interface(), ProviderInterface)
+
+
+def test_map(provider_interface):
+    """Test map."""
+    provider_interface_map = provider_interface.map
+    assert isinstance(provider_interface_map, dict)
+    assert len(provider_interface_map) > 0
+    assert "StockEOD" in provider_interface_map
+
+
+def test_required_credentials(provider_interface):
+    """Test required credentials."""
+    required_credentials = provider_interface.required_credentials
+    assert isinstance(required_credentials, dict)
+    assert len(required_credentials) > 0
+
+
+def test_model_providers(provider_interface):
+    """Test model providers."""
+    model_providers = provider_interface.model_providers
+    assert isinstance(model_providers, dict)
+    assert len(model_providers) > 0
+
+
+def test_params(provider_interface):
+    """Test params."""
+    params = provider_interface.params
+    assert isinstance(params, dict)
+    assert len(params) > 0
+    assert "StockEOD" in params
+
+
+def test_data(provider_interface):
+    """Test data."""
+    data = provider_interface.data
+    assert isinstance(data, dict)
+    assert len(data) > 0
+    assert "StockEOD" in data
+
+
+def test_merged_data(provider_interface):
+    """Test merged data."""
+    merged_data = provider_interface.merged_data
+    assert isinstance(merged_data, dict)
+    assert len(merged_data) > 0
+    assert "StockEOD" in merged_data
+
+
+def test_providers_literal(provider_interface):
+    """Test providers literal."""
+    providers_literal = provider_interface.providers_literal
+    assert isinstance(type(providers_literal), type)
+    assert len(providers_literal.__args__) > 0
+    assert "openbb" not in providers_literal.__args__
+
+
+def test_provider_choices(provider_interface):
+    """Test provider choices."""
+    provider_choices = provider_interface.provider_choices
+    assert isinstance(provider_choices, type(ProviderChoices))
+
+
+def test_models(provider_interface):
+    """Test models."""
+    models = provider_interface.models
+    assert isinstance(models, list)
+    assert len(models) > 0
+    assert "StockEOD" in models
+
+
+def test_build_registry(provider_interface):
+    """Test build registry."""
+    build_registry = provider_interface.build_registry()
+    assert isinstance(build_registry, ProviderRegistry)

openbb_sdk/sdk/core/tests/app/test_query.py

@@ -0,0 +1,126 @@
+"""Test the Query class."""
+# pylint: disable=redefined-outer-name
+
+from dataclasses import dataclass
+from unittest.mock import MagicMock, patch
+
+import pytest
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.query import Query
+from pydantic import BaseModel
+
+
+def create_mock_query():
+    """Mock query."""
+
+    class StockEOD:
+        """Mock StockEOD class."""
+
+        start_date = "2020-01-01"
+        end_date = "2020-01-05"
+        symbol = "AAPL"
+
+    return StockEOD()
+
+
+def create_mock_extra_params():
+    """Mock ExtraParams dataclass."""
+
+    @dataclass
+    class StockEOD:
+        """Mock ExtraParams dataclass."""
+
+        sort: str = "desc"
+
+    return StockEOD()
+
+
+@pytest.fixture(scope="module")
+def query():
+    """Set up query."""
+    return Query(
+        cc=CommandContext(),
+        provider_choices=ProviderChoices(provider="fmp"),
+        standard_params=StandardParams(),
+        extra_params=ExtraParams(),
+    )
+
+
+def test_init(query):
+    """Test init."""
+    assert query
+
+
+def test_to_query_params(query):
+    """Test to_query_params."""
+    standard_params = create_mock_query()
+
+    assert query.to_query_params(standard_params)
+
+
+def test_filter_extra_params(query):
+    """Test filter_extra_params."""
+    extra_params = create_mock_extra_params()
+    extra_params = query.filter_extra_params(extra_params, "fmp")
+
+    assert isinstance(extra_params, dict)
+    assert len(extra_params) == 0
+
+
+def test_filter_extra_params_wrong_param(query):
+    """Test filter_extra_params."""
+
+    @dataclass
+    class StockEOD:
+        """Mock ExtraParams dataclass."""
+
+        sort: str = "desc"
+        limit: int = 4
+
+    extra_params = StockEOD()
+
+    assert not query.filter_extra_params(extra_params, "fmp")
+
+
+@pytest.fixture
+def mock_registry():
+    """Mock registry."""
+    with patch(
+        "openbb_core.app.provider_interface.get_provider_interface"
+    ) as mock_get_provider_interface:
+        mock_registry = MagicMock()
+        mock_get_provider_interface.return_value.build_registry.return_value = (
+            mock_registry
+        )
+        yield mock_registry
+
+
+@pytest.fixture
+def query_instance():
+    """Set up query."""
+    standard_params = create_mock_query()
+    extra_params = create_mock_extra_params()
+
+    cc = CommandContext()
+    setattr(cc.user_settings.credentials, "fmp_api_key", "1234")
+
+    return Query(
+        cc=cc,
+        provider_choices=ProviderChoices(provider="fmp"),
+        standard_params=standard_params,
+        extra_params=extra_params,
+    )
+
+
+def test_execute_method_fake_credentials(query_instance, mock_registry):
+    """Test execute method without setting credentials."""
+    mock_fetch_result = BaseModel()  # Replace with an actual instance of BaseModel
+    mock_registry.fetch.return_value = mock_fetch_result
+
+    with pytest.raises(Exception):
+        query_instance.execute()

openbb_sdk/sdk/core/tests/app/test_router.py

@@ -0,0 +1,307 @@
+"""Test router.py file."""
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-argument
+
+
+import pytest
+from openbb_core.app.model.command_context import CommandContext
+from openbb_core.app.model.command_output import CommandOutput
+from openbb_core.app.provider_interface import (
+    ExtraParams,
+    ProviderChoices,
+    StandardParams,
+)
+from openbb_core.app.router import (
+    CommandMap,
+    CommandValidator,
+    Router,
+    RouterLoader,
+    SignatureInspector,
+)
+from pydantic import BaseModel
+
+
+@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),
+        (BaseModel, 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(BaseModel)
+    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),
+        (BaseModel, 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."""
+
+    def func():
+        pass
+
+    assert command_validator.check_parameters(func) is None
+    assert not command_validator.check_parameters(BaseModel)
+
+
+def test_check_return_error(command_validator):
+    """Test check_return fail."""
+    with pytest.raises(TypeError):
+
+        def func():
+            pass
+
+        command_validator.check_return(func)
+
+
+def test_check_return(command_validator):
+    """Test check_return."""
+
+    def valid_function() -> CommandOutput[int]:
+        return CommandOutput(results=[1, 2, 3])
+
+    assert command_validator.check_return(valid_function) is None
+
+
+def test_check(command_validator):
+    """Test check."""
+
+    def valid_function() -> CommandOutput[int]:
+        return CommandOutput(results=[1, 2, 3])
+
+    assert command_validator.check(valid_function) is None
+
+
+@pytest.fixture(scope="module")
+def router():
+    """Set up router."""
+    return Router()
+
+
+def test_router_init(router):
+    """Test init."""
+    assert router
+
+
+def test_command(router):
+    """Test command."""
+
+    @router.command
+    def valid_function() -> CommandOutput[int]:
+        return CommandOutput(results=[1, 2, 3])
+
+    assert valid_function
+
+
+def test_include_router(router):
+    """Test include_router."""
+    some_router = Router()
+    assert router.include_router(some_router) is None
+
+
+@pytest.fixture(scope="module")
+def router_loader():
+    """Set up router_loader."""
+    return RouterLoader()
+
+
+def test_router_loader_init(router_loader):
+    """Test init."""
+    assert router_loader
+
+
+def test_from_extensions(router_loader):
+    """Test from_extensions."""
+    assert router_loader.from_extensions()
+
+
+@pytest.fixture(scope="module")
+def signature_inspector():
+    """Set up signature_inspector."""
+    return SignatureInspector()
+
+
+def test_signature_inspector_init(signature_inspector):
+    """Test init."""
+    assert signature_inspector
+
+
+def test_complete_signature(signature_inspector):
+    """Test complete_signature."""
+
+    def sample_function(
+        cc: CommandContext,
+        provider_choices: ProviderChoices,
+        standard_params: StandardParams,
+        extra_params: ExtraParams,
+    ) -> CommandOutput:
+        pass
+
+    model = "StockEOD"
+
+    assert signature_inspector.complete_signature(sample_function, model)
+
+
+def test_complete_signature_error(signature_inspector):
+    """Test complete_signature."""
+
+    def valid_function() -> CommandOutput[int]:
+        return CommandOutput(results=[1, 2, 3])
+
+    with pytest.raises(AttributeError):
+        signature_inspector.complete_signature(valid_function, "invalid_model")
+
+
+def test_validate_signature(signature_inspector):
+    """Test validate_signature."""
+
+    def sample_function(
+        cc: CommandContext,
+        provider_choices: ProviderChoices,
+        standard_params: StandardParams,
+        extra_params: ExtraParams,
+    ) -> CommandOutput:
+        pass
+
+    expected_signature = {
+        "cc": CommandContext,
+        "provider_choices": ProviderChoices,
+        "standard_params": StandardParams,
+        "extra_params": ExtraParams,
+    }
+
+    assert (
+        signature_inspector.validate_signature(sample_function, expected_signature)
+        is None
+    )
+
+
+def test_inject_dependency(signature_inspector):
+    """Test inject_dependency."""
+
+    def sample_function(
+        cc: CommandContext,
+        provider_choices: ProviderChoices,
+        standard_params: StandardParams,
+        extra_params: ExtraParams,
+    ) -> CommandOutput:
+        pass
+
+    assert signature_inspector.inject_dependency(sample_function, "cc", CommandContext)
+
+
+def test_get_description(signature_inspector):
+    """Test get_description."""
+
+    def some_function():
+        """Mock function."""
+
+    assert signature_inspector.get_description(some_function) == some_function.__doc__
+
+
+def test_get_description_no_doc(signature_inspector):
+    """Test get_description."""
+
+    def some_function():
+        pass
+
+    assert signature_inspector.get_description(some_function) == ""
+
+
+@pytest.fixture(scope="module")
+def command_map():
+    """Set up command_map."""
+    return CommandMap()
+
+
+def test_command_map_init(command_map):
+    """Test init."""
+    assert command_map
+
+
+def test_map(command_map):
+    """Test map."""
+    assert isinstance(command_map.map, dict)
+
+
+def test_provider_coverage(command_map):
+    """Test provider_coverage."""
+    assert isinstance(command_map.provider_coverage, dict)
+
+
+def test_command_coverage(command_map):
+    """Test command_coverage."""
+    assert isinstance(command_map.command_coverage, dict)
+
+
+def test_get_command_map(command_map, router):
+    """Test get_command_map."""
+    command_map = command_map.get_command_map(router)
+    assert isinstance(command_map, dict)
+    assert len(command_map) > 0
+
+
+def test_get_provider_coverage(command_map, router):
+    """Test get_provider_coverage."""
+    provider_coverage = command_map.get_provider_coverage(router)
+    assert isinstance(provider_coverage, dict)
+
+
+def test_get_command_coverage(command_map, router):
+    """Test get_command_coverage."""
+    command_coverage = command_map.get_command_coverage(router)
+    assert isinstance(command_coverage, dict)
+
+
+def test_get_command(command_map):
+    """Test get_command."""
+    command = command_map.get_command("stocks/load")
+    assert command is None