From 74a232c830de5620ffe93cdf13cc8d9b57ce957e Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Thu, 28 Sep 2023 15:30:16 +0200 Subject: [PATCH 01/45] Test provider coverage of the python interface integration tests --- .../tests/test_integration_tests.py | 15 ++++ .../tests/utils/integration_tests_testers.py | 80 +++++++++++++++++++ pytest.ini | 1 + 3 files changed, 96 insertions(+) create mode 100644 openbb_sdk/extensions/tests/test_integration_tests.py create mode 100644 openbb_sdk/extensions/tests/utils/integration_tests_testers.py diff --git a/openbb_sdk/extensions/tests/test_integration_tests.py b/openbb_sdk/extensions/tests/test_integration_tests.py new file mode 100644 index 00000000000..7908a19076e --- /dev/null +++ b/openbb_sdk/extensions/tests/test_integration_tests.py @@ -0,0 +1,15 @@ +"""Test the integration tests.""" +from extensions.tests.utils.integration_tests_testers import ( + check_missing_integration_test_providers, + get_module_functions, + get_python_integration_tests, +) + + +def test_python_interface_integration_tests() -> None: + """Test if there are any missing providers for integration tests.""" + integration_tests = get_python_integration_tests() + functions = get_module_functions(integration_tests) + missing_providers = check_missing_integration_test_providers(functions) + + assert not missing_providers, "\n".join(missing_providers) diff --git a/openbb_sdk/extensions/tests/utils/integration_tests_testers.py b/openbb_sdk/extensions/tests/utils/integration_tests_testers.py new file mode 100644 index 00000000000..c085475246c --- /dev/null +++ b/openbb_sdk/extensions/tests/utils/integration_tests_testers.py @@ -0,0 +1,80 @@ +"""Test if there are any missing providers for python interface integration tests.""" +import importlib.util +import inspect +import os +from typing import Any, Dict, List + +from extensions.tests.utils.integration_tests_generator import find_extensions +from sdk.core.openbb_core.app.provider_interface import ProviderInterface +from sdk.core.openbb_core.app.router import CommandMap + + +def get_python_integration_tests() -> List[Any]: + """Get integration tests for the python interface.""" + integration_tests: List[Any] = [] + + for extension in find_extensions(): + integration_folder = os.path.join(extension, "integration") + for file in os.listdir(integration_folder): + if file.endswith("_python.py"): + file_path = os.path.join(integration_folder, file) + module_name = file[:-3] # Remove .py from file name + + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec: + module = importlib.util.module_from_spec(spec) + if spec.loader: + spec.loader.exec_module(module) + integration_tests.append(module) + + return integration_tests + + +def get_module_functions(module_list: List[Any]) -> Dict[str, Any]: + """Get all functions from a list of modules.""" + functions = {} + for module in module_list: + for name, obj in inspect.getmembers(module): + if inspect.isfunction(obj): + functions[name] = obj + return functions + + +def check_missing_integration_test_providers(functions: Dict[str, Any]) -> List[str]: + """Check if there are any missing providers for integration tests.""" + pi = ProviderInterface() + provider_interface_map = pi.map + cm = CommandMap(coverage_sep=".") + + missing_providers: List[str] = [] + + for command, model in cm.commands_model.items(): + for function in functions: + if command[1:].replace(".", "_") == function.replace("test_", ""): + command_params: Dict[str, Dict[str, dict]] = provider_interface_map[ + model + ] + function_params: List[dict] = functions[function].pytestmark[1].args[1] + + providers = list(command_params.keys()) + providers.remove("openbb") + + for test_params in function_params: + provider = test_params.get("provider", None) + if provider: + try: # noqa + providers.remove(provider) + except ValueError: + pass + + if providers: + # if there is only one provider left and the length of the + # test_params is 1, we can ignore because it is picked up by default + if len(providers) == 1 and len(function_params) == 1: + pass + else: + missing_providers.append( + f"Missing providers for {function}: {providers}" + ) + + return missing_providers diff --git a/pytest.ini b/pytest.ini index 3454f71f138..1b499680ac9 100644 --- a/pytest.ini +++ b/pytest.ini @@ -2,6 +2,7 @@ addopts = -p no:warnings markers = linux: tests that are not stable on Windows + integration: OpenBB Platform integration test marker testpaths = tests openbb_sdk/**/tests From a92dfa5650c6693f9ffcd13f73d9fc4fb8cc0c13 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 29 Sep 2023 00:04:35 +0200 Subject: [PATCH 02/45] Test params and providers --- .../tests/test_integration_tests.py | 10 ++ .../tests/utils/integration_tests_testers.py | 96 ++++++++++++++----- 2 files changed, 83 insertions(+), 23 deletions(-) diff --git a/openbb_sdk/extensions/tests/test_integration_tests.py b/openbb_sdk/extensions/tests/test_integration_tests.py index 7908a19076e..6509094eff7 100644 --- a/openbb_sdk/extensions/tests/test_integration_tests.py +++ b/openbb_sdk/extensions/tests/test_integration_tests.py @@ -1,5 +1,6 @@ """Test the integration tests.""" from extensions.tests.utils.integration_tests_testers import ( + check_missing_integration_test_params, check_missing_integration_test_providers, get_module_functions, get_python_integration_tests, @@ -13,3 +14,12 @@ def test_python_interface_integration_tests() -> None: missing_providers = check_missing_integration_test_providers(functions) assert not missing_providers, "\n".join(missing_providers) + + +def test_python_interface_integration_test_params() -> None: + """Test if there are any missing params for integration tests.""" + integration_tests = get_python_integration_tests() + functions = get_module_functions(integration_tests) + missing_params = check_missing_integration_test_params(functions) + + assert not missing_params, "\n".join(missing_params) diff --git a/openbb_sdk/extensions/tests/utils/integration_tests_testers.py b/openbb_sdk/extensions/tests/utils/integration_tests_testers.py index c085475246c..92a1d942a6f 100644 --- a/openbb_sdk/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_sdk/extensions/tests/utils/integration_tests_testers.py @@ -2,7 +2,7 @@ import importlib.util import inspect import os -from typing import Any, Dict, List +from typing import Any, Callable, Dict, List from extensions.tests.utils.integration_tests_generator import find_extensions from sdk.core.openbb_core.app.provider_interface import ProviderInterface @@ -40,13 +40,69 @@ def get_module_functions(module_list: List[Any]) -> Dict[str, Any]: return functions -def check_missing_integration_test_providers(functions: Dict[str, Any]) -> List[str]: - """Check if there are any missing providers for integration tests.""" +def check_missing_providers( + command_params: Dict[str, Dict[str, dict]], + function_params: List[dict], + function, +) -> List[str]: + """Check if there are any missing providers for a command.""" + missing_providers: List[str] = [] + providers = list(command_params.keys()) + providers.remove("openbb") + + for test_params in function_params: + provider = test_params.get("provider", None) + if provider: + try: # noqa + providers.remove(provider) + except ValueError: + pass + + if providers: + # if there is only one provider left and the length of the + # test_params is 1, we can ignore because it is picked up by default + if len(providers) == 1 and len(function_params) == 1: + pass + else: + missing_providers.append(f"Missing providers for {function}: {providers}") + + return missing_providers + + +def check_missing_params( + command_params: Dict[str, Dict[str, dict]], function_params: List[dict], function +) -> List[str]: + """Check if there are any missing params for a command.""" + missing_params = [] + for test_params in function_params: + if "provider" in test_params: + provider = test_params["provider"] + if provider in command_params: + for expected_param in command_params[provider]["QueryParams"]["fields"]: + if expected_param not in test_params.keys(): + missing_params.append( + f"Missing param {expected_param} for provider {provider} in function {function}" + ) + else: + for expected_param in command_params["openbb"]["QueryParams"]["fields"]: + if expected_param not in test_params.keys(): + missing_params.append( + f"Missing standard param {expected_param} in function {function}" + ) + + return missing_params + + +def check_integration_tests( + functions: Dict[str, Any], + check_function: Callable[[Dict[str, Dict[str, dict]], List[dict], str], List[str]], +) -> List[str]: + """Check if there are any missing items for integration tests.""" pi = ProviderInterface() provider_interface_map = pi.map cm = CommandMap(coverage_sep=".") - missing_providers: List[str] = [] + all_missing_items: List[str] = [] for command, model in cm.commands_model.items(): for function in functions: @@ -56,25 +112,19 @@ def check_missing_integration_test_providers(functions: Dict[str, Any]) -> List[ ] function_params: List[dict] = functions[function].pytestmark[1].args[1] - providers = list(command_params.keys()) - providers.remove("openbb") + missing_items = check_function( + command_params, function_params, function + ) + all_missing_items.extend(missing_items) - for test_params in function_params: - provider = test_params.get("provider", None) - if provider: - try: # noqa - providers.remove(provider) - except ValueError: - pass + return all_missing_items - if providers: - # if there is only one provider left and the length of the - # test_params is 1, we can ignore because it is picked up by default - if len(providers) == 1 and len(function_params) == 1: - pass - else: - missing_providers.append( - f"Missing providers for {function}: {providers}" - ) - return missing_providers +def check_missing_integration_test_providers(functions: Dict[str, Any]) -> List[str]: + """Check if there are any missing providers for integration tests.""" + return check_integration_tests(functions, check_missing_providers) + + +def check_missing_integration_test_params(functions: Dict[str, Any]) -> List[str]: + """Check if there are any missing params for integration tests.""" + return check_integration_tests(functions, check_missing_params) From dfd48d260579d64855a60a779c863ed91b32b4ea Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 29 Sep 2023 12:08:10 +0200 Subject: [PATCH 03/45] Cleanup --- .../extensions/tests/utils/integration_tests_generator.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/openbb_sdk/extensions/tests/utils/integration_tests_generator.py b/openbb_sdk/extensions/tests/utils/integration_tests_generator.py index 3d3934b4b22..144ea4e5ed9 100644 --- a/openbb_sdk/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_sdk/extensions/tests/utils/integration_tests_generator.py @@ -4,6 +4,7 @@ from typing import Any, Dict, List, Literal, get_origin from pydantic.fields import FieldInfo from pydantic_core import PydanticUndefined + from sdk.core.openbb_core.app.provider_interface import ProviderInterface from sdk.core.openbb_core.app.router import CommandMap @@ -179,6 +180,3 @@ def write_integration_test() -> None: extensions = find_extensions() create_integration_test_files(extensions) add_test_commands_to_file(extensions) - - -write_integration_test() From 2a4e93e8c5065c91222268a8ca05d19f24321b14 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Mon, 2 Oct 2023 17:13:57 +0200 Subject: [PATCH 04/45] Fix imports --- .../extensions/tests/utils/integration_tests_testers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 92a1d942a6f..ea4f248c9b3 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -2,11 +2,11 @@ import importlib.util import inspect import os +from platform.core.openbb_core.app.provider_interface import ProviderInterface +from platform.core.openbb_core.app.router import CommandMap from typing import Any, Callable, Dict, List from extensions.tests.utils.integration_tests_generator import find_extensions -from sdk.core.openbb_core.app.provider_interface import ProviderInterface -from sdk.core.openbb_core.app.router import CommandMap def get_python_integration_tests() -> List[Any]: From 9a9cc14ec145f4133e69a389f8a032e35fee2ea3 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Mon, 2 Oct 2023 17:34:58 +0200 Subject: [PATCH 05/45] Test API integration tests --- .../tests/test_integration_tests.py | 31 +++++++++++++------ .../tests/utils/integration_tests_testers.py | 15 ++++++--- 2 files changed, 31 insertions(+), 15 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests.py b/openbb_platform/extensions/tests/test_integration_tests.py index 6509094eff7..e59987d111f 100644 --- a/openbb_platform/extensions/tests/test_integration_tests.py +++ b/openbb_platform/extensions/tests/test_integration_tests.py @@ -2,24 +2,35 @@ from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, + get_integration_tests, get_module_functions, - get_python_integration_tests, ) +def run_test(test_type: str, check_function) -> None: + """Run tests helper function.""" + integration_tests = get_integration_tests(test_type=test_type) + functions = get_module_functions(integration_tests) + missing_items = check_function(functions) + + assert not missing_items, "\n".join(missing_items) + + def test_python_interface_integration_tests() -> None: """Test if there are any missing providers for integration tests.""" - integration_tests = get_python_integration_tests() - functions = get_module_functions(integration_tests) - missing_providers = check_missing_integration_test_providers(functions) - - assert not missing_providers, "\n".join(missing_providers) + run_test("unit", check_missing_integration_test_providers) def test_python_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" - integration_tests = get_python_integration_tests() - functions = get_module_functions(integration_tests) - missing_params = check_missing_integration_test_params(functions) + run_test("unit", check_missing_integration_test_params) - assert not missing_params, "\n".join(missing_params) + +def test_api_interface_integration_tests() -> None: + """Test if there are any missing providers for integration tests.""" + run_test("integration", check_missing_integration_test_providers) + + +def test_api_interface_integration_test_params() -> None: + """Test if there are any missing params for integration tests.""" + run_test("integration", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index ea4f248c9b3..28864f063d5 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -2,21 +2,26 @@ import importlib.util import inspect import os -from platform.core.openbb_core.app.provider_interface import ProviderInterface -from platform.core.openbb_core.app.router import CommandMap -from typing import Any, Callable, Dict, List +from typing import Any, Callable, Dict, List, Literal from extensions.tests.utils.integration_tests_generator import find_extensions +from openbb_core.app.provider_interface import ProviderInterface +from openbb_core.app.router import CommandMap -def get_python_integration_tests() -> List[Any]: +def get_integration_tests(test_type: Literal["integration", "unit"]) -> List[Any]: """Get integration tests for the python interface.""" integration_tests: List[Any] = [] + if test_type == "unit": + file_end = "_python.py" + elif test_type == "integration": + file_end = "_api.py" + for extension in find_extensions(): integration_folder = os.path.join(extension, "integration") for file in os.listdir(integration_folder): - if file.endswith("_python.py"): + if file.endswith(file_end): file_path = os.path.join(integration_folder, file) module_name = file[:-3] # Remove .py from file name From d049d616eebe522e8c022332ca8c83cc7bec81e1 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Mon, 2 Oct 2023 17:57:29 +0200 Subject: [PATCH 06/45] Fix docstring --- .../extensions/tests/utils/integration_tests_testers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 28864f063d5..e8042546172 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -10,7 +10,7 @@ from openbb_core.app.router import CommandMap def get_integration_tests(test_type: Literal["integration", "unit"]) -> List[Any]: - """Get integration tests for the python interface.""" + """Get integration tests for the OpenBB Platform.""" integration_tests: List[Any] = [] if test_type == "unit": From ab5d485b85513a0e50de853a18f151a45b06dd82 Mon Sep 17 00:00:00 2001 From: Henrique Joaquim Date: Tue, 3 Oct 2023 15:33:06 +0100 Subject: [PATCH 07/45] Feature/integration tests python data processing cmds (#5511) * chaging the generator to handle data processing commands * ruff n black --- .../integration/test_econometrics_python.py | 209 +++++++ .../qa/integration/test_qa_python.py | 170 ++++++ .../ta/integration/test_ta_python.py | 527 ++++++++++++++++++ .../utils/integration_tests_generator.py | 196 ++++--- 4 files changed, 1034 insertions(+), 68 deletions(-) create mode 100644 openbb_platform/extensions/econometrics/integration/test_econometrics_python.py create mode 100644 openbb_platform/extensions/qa/integration/test_qa_python.py create mode 100644 openbb_platform/extensions/ta/integration/test_ta_python.py diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py new file mode 100644 index 00000000000..6ebf3068ec9 --- /dev/null +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -0,0 +1,209 @@ +"""Test econometrics extension.""" +import pytest +from openbb_core.app.model.obbject import OBBject + + +@pytest.fixture(scope="session") +def obb(pytestconfig): + """Fixture to setup obb.""" + + if pytestconfig.getoption("markexpr") != "not integration": + import openbb + + return openbb.obb + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_corr(params, obb): + result = obb.econometrics.corr(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_ols(params, obb): + result = obb.econometrics.ols(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_ols_summary(params, obb): + result = obb.econometrics.ols_summary(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_dwat(params, obb): + result = obb.econometrics.dwat(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "lags": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_bgot(params, obb): + result = obb.econometrics.bgot(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_coint(params, obb): + result = obb.econometrics.coint(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_column": "", "lag": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_granger(params, obb): + result = obb.econometrics.granger(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "column": "", "regression": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_unitroot(params, obb): + result = obb.econometrics.unitroot(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelre(params, obb): + result = obb.econometrics.panelre(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelbols(params, obb): + result = obb.econometrics.panelbols(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelpols(params, obb): + result = obb.econometrics.panelpols(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelols(params, obb): + result = obb.econometrics.panelols(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelfd(params, obb): + result = obb.econometrics.panelfd(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_econometrics_panelfmac(params, obb): + result = obb.econometrics.panelfmac(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 diff --git a/openbb_platform/extensions/qa/integration/test_qa_python.py b/openbb_platform/extensions/qa/integration/test_qa_python.py new file mode 100644 index 00000000000..a64330bf5e4 --- /dev/null +++ b/openbb_platform/extensions/qa/integration/test_qa_python.py @@ -0,0 +1,170 @@ +"""Test qa extension.""" +import pytest +from openbb_core.app.model.obbject import OBBject + + +@pytest.fixture(scope="session") +def obb(pytestconfig): + """Fixture to setup obb.""" + + if pytestconfig.getoption("markexpr") != "not integration": + import openbb + + return openbb.obb + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_normality(params, obb): + result = obb.qa.normality(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_capm(params, obb): + result = obb.qa.capm(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "threshold_start": "", + "threshold_end": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_qa_om(params, obb): + result = obb.qa.om(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "window": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_kurtosis(params, obb): + result = obb.qa.kurtosis(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "fuller_reg": "", "kpss_reg": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_unitroot(params, obb): + result = obb.qa.unitroot(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "rfr": "", "window": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_sh(params, obb): + result = obb.qa.sh(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "target_return": "", + "window": "", + "adjusted": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_qa_so(params, obb): + result = obb.qa.so(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "window": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_skew(params, obb): + result = obb.qa.skew(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "window": "", "quantile_pct": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_quantile(params, obb): + result = obb.qa.quantile(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "target": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_qa_summary(params, obb): + result = obb.qa.summary(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 diff --git a/openbb_platform/extensions/ta/integration/test_ta_python.py b/openbb_platform/extensions/ta/integration/test_ta_python.py new file mode 100644 index 00000000000..ca9d5dd3bee --- /dev/null +++ b/openbb_platform/extensions/ta/integration/test_ta_python.py @@ -0,0 +1,527 @@ +"""Test ta extension.""" +import pytest +from openbb_core.app.model.obbject import OBBject + + +@pytest.fixture(scope="session") +def obb(pytestconfig): + """Fixture to setup obb.""" + + if pytestconfig.getoption("markexpr") != "not integration": + import openbb + + return openbb.obb + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "length": "", + "mamode": "", + "drift": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_atr(params, obb): + result = obb.ta.atr(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "close_column": "", + "period": "", + "start_date": "", + "end_date": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_fib(params, obb): + result = obb.ta.fib(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "offset": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_obv(params, obb): + result = obb.ta.obv(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "length": "", "signal": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_fisher(params, obb): + result = obb.ta.fisher(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "fast": "", "slow": "", "offset": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_adosc(params, obb): + result = obb.ta.adosc(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "std": "", + "mamode": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_bbands(params, obb): + result = obb.ta.bbands(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_zlma(params, obb): + result = obb.ta.zlma(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "length": "", "scalar": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_aroon(params, obb): + result = obb.ta.aroon(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_sma(params, obb): + result = obb.ta.sma(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "target": "", + "show_all": "", + "asint": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_demark(params, obb): + result = obb.ta.demark(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "anchor": "", "offset": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_vwap(params, obb): + result = obb.ta.vwap(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "fast": "", + "slow": "", + "signal": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_macd(params, obb): + result = obb.ta.macd(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_hma(params, obb): + result = obb.ta.hma(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "lower_length": "", + "upper_length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_donchian(params, obb): + result = obb.ta.donchian(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "conversion": "", + "base": "", + "lagging": "", + "offset": "", + "lookahead": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_ichimoku(params, obb): + result = obb.ta.ichimoku(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "target": "", "period": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_clenow(params, obb): + result = obb.ta.clenow(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "length": "", + "scalar": "", + "drift": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_adx(params, obb): + result = obb.ta.adx(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_wma(params, obb): + result = obb.ta.wma(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "length": "", "scalar": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_cci(params, obb): + result = obb.ta.cci(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "scalar": "", + "drift": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_rsi(params, obb): + result = obb.ta.rsi(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "fast_k_period": "", + "slow_d_period": "", + "slow_k_period": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_stoch(params, obb): + result = obb.ta.stoch(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "length": "", + "scalar": "", + "mamode": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_kc(params, obb): + result = obb.ta.kc(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ({"data": "", "index": "", "length": "", "return": ""}), + ], +) +@pytest.mark.integration +def test_ta_cg(params, obb): + result = obb.ta.cg(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "index": "", + "lower_q": "", + "upper_q": "", + "model": "", + "is_crypto": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_cones(params, obb): + result = obb.ta.cones(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": "", + "target": "", + "index": "", + "length": "", + "offset": "", + "return": "", + } + ), + ], +) +@pytest.mark.integration +def test_ta_ema(params, obb): + result = obb.ta.ema(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 diff --git a/openbb_platform/extensions/tests/utils/integration_tests_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_generator.py index eb790686a92..b3a53b4dd90 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_generator.py @@ -1,18 +1,30 @@ """Integration test generator.""" from pathlib import Path, PosixPath -from typing import Any, Dict, List, Literal, get_origin +from typing import Any, Dict, List, Literal, Tuple, Type, get_origin, get_type_hints from openbb_core.app.provider_interface import ProviderInterface from openbb_core.app.router import CommandMap from pydantic.fields import FieldInfo from pydantic_core import PydanticUndefined -cm = CommandMap(coverage_sep=".") +TEST_TEMPLATE = """\n\n@pytest.mark.parametrize( + "params", + [ + {params} + ], +) +@pytest.mark.integration +def test_{test_name}(params, obb): + result = obb.{command_name}(**params) + assert result + assert isinstance(result, OBBject) + assert len(result.results) > 0 +""" def find_extensions(): """Find extensions.""" - filter_ext = ["tests", "ta", "qa", "econometrics", "charting"] + filter_ext = ["tests", "charting"] extensions = [x for x in Path("openbb_platform/extensions").iterdir() if x.is_dir()] extensions = [x for x in extensions if x.name not in filter_ext] return extensions @@ -103,83 +115,131 @@ def get_test_params( return test_params_list +def get_test_params_data_processing(hints: Dict[str, Type]): + return list(hints.keys()) + + +def get_full_command_name_and_test_name(route: str) -> Tuple[str, str]: + """Get the full command name and test name.""" + + cmd_parts = route.split("/") + del cmd_parts[0] + + menu = cmd_parts[0] + command = cmd_parts[-1] + sub_menus = cmd_parts[1:-1] + + sub_menus_str_test_name = f"_{'_'.join(sub_menus)}" if sub_menus else "" + sub_menu_str_cmd = f".{'.'.join(sub_menus)}" if sub_menus else "" + + full_command = f"{menu}{sub_menu_str_cmd}.{command}" + test_name = f"{menu}{sub_menus_str_test_name}_{command}" + + return test_name, full_command + + +def test_exists(command_name: str, path: str): + with open(path) as f: + return command_name in f.read() + + +def write_to_file_w_template(test_file, params_list, full_command, test_name): + params = "" + for test_params in params_list: + params += f"({test_params}),\n" + + if not test_exists(command_name=full_command, path=test_file): + with open(test_file, "a", encoding="utf-8", newline="\n") as f: + f.write( + TEST_TEMPLATE.format( + test_name=test_name, + command_name=full_command, + params=params, + ) + ) + + +def write_test( + test_file: PosixPath, + commands_model: Dict[str, str], + extension_name: str, + provider_interface_map: Dict[str, Any], +): + """Write test.""" + + for route, model in commands_model.items(): + if extension_name in route and route.startswith(f"/{extension_name}/"): + test_name, full_command = get_full_command_name_and_test_name(route=route) + + test_params_list = get_test_params( + model_name=model, + provider_interface_map=provider_interface_map, + ) + + write_to_file_w_template( + test_file=test_file, + params_list=test_params_list, + full_command=full_command, + test_name=test_name, + ) + + +def write_test_data_processing( + test_file: PosixPath, commands_map: Dict[str, str], extension_name: str +): + """Write test for data processing commands.""" + + for route, _ in commands_map.items(): + if extension_name in route and route.startswith(f"/{extension_name}/"): + test_name, full_command = get_full_command_name_and_test_name(route=route) + + hints = get_type_hints(commands_map[route]) + test_params_list = [{k: "" for k in get_test_params_data_processing(hints)}] + + write_to_file_w_template( + test_file=test_file, + params_list=test_params_list, + full_command=full_command, + test_name=test_name, + ) + + def add_test_commands_to_file( # pylint: disable=W0102 extensions: List[PosixPath], - commands_model: Dict[str, str] = cm.commands_model, ) -> None: """Add test commands to file.""" + provider_interface = ProviderInterface() provider_interface_map = provider_interface.map - template = """\n\n@pytest.mark.parametrize( - "params", - [ - {params} - ], -) -@pytest.mark.integration -def test_{test_name}(**params, obb): - result = obb.{command_name}(**params) - assert result - assert isinstance(result, OBBject) - assert len(result.results) > 0 -""" + cm = CommandMap() + commands_model = cm.commands_model + commands_map = cm.map + + extensions_names = [path.name for path in extensions] + extensions_w_models = list({route.split("/")[1] for route in commands_model}) + extensions_data_processing = [ + ext for ext in extensions_names if ext not in extensions_w_models + ] + for extension in extensions: extension_name = extension.name test_file_name = f"test_{extension_name}_python.py" test_file = extension / "integration" / test_file_name - with open(test_file, "a", encoding="utf-8", newline="\n") as f: - for command in commands_model: - if extension_name in command and command.startswith( - f".{extension_name}." - ): - extension_name = command.split(".")[1] - if len(command.split(".")) > 3: - test_name = ( - extension_name - + "_" - + command.split(".")[2] - + "_" - + command.split(".")[3] - ) - elif len(command.split(".")) == 3: - test_name = extension_name + "_" + command.split(".")[2] - - command_name = command.split(".")[-1] - if "_" in command_name: - full_command_name = test_name.replace("_", ".", 2) - # The code below double checks if the full command name is correct. - # This eliminates edge cases. - fix_full_command_name = full_command_name.split(".") - for i, part in enumerate(fix_full_command_name): - if part == command_name.split("_")[0]: - fix_full_command_name[i] = command_name - fix_full_command_name.pop() - - full_command_name = ".".join(fix_full_command_name) - - else: - full_command_name = test_name.replace("_", ".") - - test_params_list = get_test_params( - model_name=commands_model[command], - provider_interface_map=provider_interface_map, - ) - - params = "" - for test_params in test_params_list: - params += f"({test_params}),\n" - - read_file = open(test_file) # noqa - if full_command_name not in read_file.read(): - f.write( - template.format( - test_name=test_name, - command_name=full_command_name, - params=params, - ) - ) + if extension_name in extensions_data_processing: + write_test_data_processing( + test_file=test_file, + commands_map=commands_map, + extension_name=extension_name, + ) + else: + write_test( + test_file=test_file, + commands_model=commands_model, + extension_name=extension_name, + provider_interface_map=provider_interface_map, + ) def write_integration_test() -> None: From 1cc8f22e2ff442ef812664fb27db58a344ad19c9 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Tue, 3 Oct 2023 18:56:30 +0100 Subject: [PATCH 08/45] pointing to platform --- .github/workflows/api-integration-test.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/api-integration-test.yml b/.github/workflows/api-integration-test.yml index 313b65ea060..179ca07d56e 100644 --- a/.github/workflows/api-integration-test.yml +++ b/.github/workflows/api-integration-test.yml @@ -47,7 +47,7 @@ jobs: - name: Install Python Dependencies run: | - pip install toml pytest uvicorn importlib-metadata + pip install toml pytest uvicorn # - name: Load cached venv # id: cached-poetry-dependencies @@ -90,7 +90,7 @@ jobs: - name: Run Integration Tests run: | - pytest -m integration + pytest ${{ github.workspace }}/openbb_platform/ -m integration # - name: Upload summary to Slack # uses: adrey/slack-file-upload-action@master From 3c840beb70b837cb57f0f4481c57c749b814b46a Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Tue, 3 Oct 2023 18:59:18 +0100 Subject: [PATCH 09/45] Revert "pointing to platform" This reverts commit 1cc8f22e2ff442ef812664fb27db58a344ad19c9. --- .github/workflows/api-integration-test.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/api-integration-test.yml b/.github/workflows/api-integration-test.yml index 179ca07d56e..313b65ea060 100644 --- a/.github/workflows/api-integration-test.yml +++ b/.github/workflows/api-integration-test.yml @@ -47,7 +47,7 @@ jobs: - name: Install Python Dependencies run: | - pip install toml pytest uvicorn + pip install toml pytest uvicorn importlib-metadata # - name: Load cached venv # id: cached-poetry-dependencies @@ -90,7 +90,7 @@ jobs: - name: Run Integration Tests run: | - pytest ${{ github.workspace }}/openbb_platform/ -m integration + pytest -m integration # - name: Upload summary to Slack # uses: adrey/slack-file-upload-action@master From 98771e060e8bd22b55d3fc890a7b3e3b751bc2ce Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 15:20:46 +0200 Subject: [PATCH 10/45] Processing tests QA --- .../tests/test_integration_tests.py | 3 + .../utils/integration_tests_generator.py | 12 +-- .../tests/utils/integration_tests_testers.py | 90 ++++++++++++++----- 3 files changed, 79 insertions(+), 26 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests.py b/openbb_platform/extensions/tests/test_integration_tests.py index e59987d111f..6878c705c1d 100644 --- a/openbb_platform/extensions/tests/test_integration_tests.py +++ b/openbb_platform/extensions/tests/test_integration_tests.py @@ -34,3 +34,6 @@ def test_api_interface_integration_tests() -> None: def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("integration", check_missing_integration_test_params) + + +test_python_interface_integration_test_params() diff --git a/openbb_platform/extensions/tests/utils/integration_tests_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_generator.py index b3a53b4dd90..8605d0a539d 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_generator.py @@ -82,7 +82,7 @@ def get_model_params(param_fields: Dict[str, FieldInfo]) -> Dict[str, Any]: elif field.annotation == bool: test_params[field_name] = True elif get_origin(field.annotation) is Literal: - test_params[field_name] = field.annotation.__args__[0] + test_params[field_name] = field.annotation.__args__[0] # type: ignore return test_params @@ -116,12 +116,12 @@ def get_test_params( def get_test_params_data_processing(hints: Dict[str, Type]): + """Get the test params for the data processing commands.""" return list(hints.keys()) def get_full_command_name_and_test_name(route: str) -> Tuple[str, str]: """Get the full command name and test name.""" - cmd_parts = route.split("/") del cmd_parts[0] @@ -139,11 +139,13 @@ def get_full_command_name_and_test_name(route: str) -> Tuple[str, str]: def test_exists(command_name: str, path: str): + """Check if test exists.""" with open(path) as f: return command_name in f.read() def write_to_file_w_template(test_file, params_list, full_command, test_name): + """Write to file with template.""" params = "" for test_params in params_list: params += f"({test_params}),\n" @@ -166,7 +168,6 @@ def write_test( provider_interface_map: Dict[str, Any], ): """Write test.""" - for route, model in commands_model.items(): if extension_name in route and route.startswith(f"/{extension_name}/"): test_name, full_command = get_full_command_name_and_test_name(route=route) @@ -188,7 +189,6 @@ def write_test_data_processing( test_file: PosixPath, commands_map: Dict[str, str], extension_name: str ): """Write test for data processing commands.""" - for route, _ in commands_map.items(): if extension_name in route and route.startswith(f"/{extension_name}/"): test_name, full_command = get_full_command_name_and_test_name(route=route) @@ -208,7 +208,6 @@ def add_test_commands_to_file( # pylint: disable=W0102 extensions: List[PosixPath], ) -> None: """Add test commands to file.""" - provider_interface = ProviderInterface() provider_interface_map = provider_interface.map @@ -249,4 +248,5 @@ def write_integration_test() -> None: add_test_commands_to_file(extensions) -write_integration_test() +if __name__ == "__main__": + write_integration_test() diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index e8042546172..f0b820b53f5 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -2,9 +2,12 @@ import importlib.util import inspect import os -from typing import Any, Callable, Dict, List, Literal +from typing import Any, Callable, Dict, List, Literal, Union, get_type_hints -from extensions.tests.utils.integration_tests_generator import find_extensions +from extensions.tests.utils.integration_tests_generator import ( + find_extensions, + get_test_params_data_processing, +) from openbb_core.app.provider_interface import ProviderInterface from openbb_core.app.router import CommandMap @@ -46,11 +49,15 @@ def get_module_functions(module_list: List[Any]) -> Dict[str, Any]: def check_missing_providers( - command_params: Dict[str, Dict[str, dict]], + command_params: Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], function_params: List[dict], function, + processing: bool = False, ) -> List[str]: """Check if there are any missing providers for a command.""" + if processing or not isinstance(command_params, dict): + return [] + missing_providers: List[str] = [] providers = list(command_params.keys()) providers.remove("openbb") @@ -75,39 +82,62 @@ def check_missing_providers( def check_missing_params( - command_params: Dict[str, Dict[str, dict]], function_params: List[dict], function + command_params: Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], + function_params: List[dict], + function, + processing: bool = False, ) -> List[str]: """Check if there are any missing params for a command.""" missing_params = [] - for test_params in function_params: - if "provider" in test_params: - provider = test_params["provider"] - if provider in command_params: - for expected_param in command_params[provider]["QueryParams"]["fields"]: + if not processing: + for test_params in function_params: + if "provider" in test_params: + provider = test_params["provider"] + if provider in command_params: + for expected_param in command_params[provider]["QueryParams"][ + "fields" + ]: + if expected_param not in test_params.keys(): + missing_params.append( + f"Missing param {expected_param} for provider {provider} in function {function}" + ) + elif isinstance(command_params, dict): + for expected_param in command_params["openbb"]["QueryParams"]["fields"]: if expected_param not in test_params.keys(): missing_params.append( - f"Missing param {expected_param} for provider {provider} in function {function}" + f"Missing standard param {expected_param} in function {function}" + ) + else: + for test_params in function_params: + if isinstance(command_params, list): + for expected_param in command_params[0]: + if expected_param not in test_params.keys(): + missing_params.append( + f"Missing param {expected_param} in function {function}" ) - else: - for expected_param in command_params["openbb"]["QueryParams"]["fields"]: - if expected_param not in test_params.keys(): - missing_params.append( - f"Missing standard param {expected_param} in function {function}" - ) - return missing_params def check_integration_tests( functions: Dict[str, Any], - check_function: Callable[[Dict[str, Dict[str, dict]], List[dict], str], List[str]], + check_function: Callable[ + [ + Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], + List[dict], + str, + bool, + ], + List[str], + ], ) -> List[str]: """Check if there are any missing items for integration tests.""" pi = ProviderInterface() provider_interface_map = pi.map cm = CommandMap(coverage_sep=".") + function_params: List[dict] = [] all_missing_items: List[str] = [] + used_functions: List[str] = [] for command, model in cm.commands_model.items(): for function in functions: @@ -115,10 +145,30 @@ def check_integration_tests( command_params: Dict[str, Dict[str, dict]] = provider_interface_map[ model ] - function_params: List[dict] = functions[function].pytestmark[1].args[1] + function_params = functions[function].pytestmark[1].args[1] missing_items = check_function( - command_params, function_params, function + command_params, function_params, function, False + ) + all_missing_items.extend(missing_items) + used_functions.append(function) + + # the processing commands are the ones that are left + processing_functions = [ + function for function in functions if function not in used_functions + ] + + for route, _ in cm.map.items(): + for function in processing_functions: + if route.replace("/", "_")[1:] == function.replace("test_", ""): + hints = get_type_hints(cm.map[route]) + processing_command_params = [ + {k: "" for k in get_test_params_data_processing(hints)} + ] + function_params = functions[function].pytestmark[1].args[1] + + missing_items = check_function( + processing_command_params, function_params, function, True ) all_missing_items.extend(missing_items) From 04d705e43ecd59d654e814677316bf2dcdf56b27 Mon Sep 17 00:00:00 2001 From: Henrique Joaquim Date: Wed, 4 Oct 2023 14:56:43 +0100 Subject: [PATCH 11/45] Feature/int tests data processing (#5526) * adjustments to the generator * econometrics * qa * ta * improving api tests * adjustments to python tests * test ci * Revert "test ci" This reverts commit 9dce36292025d9b645cf257751cb49a921b2671b. * remove changes from package * removing packaged stuff --- .../integration/test_econometrics_api.py | 65 ++-- .../integration/test_econometrics_python.py | 147 ++++++- .../extensions/qa/integration/test_qa_api.py | 95 +++-- .../qa/integration/test_qa_python.py | 195 +++++++--- .../extensions/ta/integration/test_ta_api.py | 140 ++++--- .../ta/integration/test_ta_python.py | 366 +++++++++++++++--- .../utils/integration_tests_generator.py | 4 + 7 files changed, 781 insertions(+), 231 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 631a33b6f0f..bf7f0b88343 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -28,34 +28,45 @@ def headers(): return h -def get_random_data(menu: str, symbols: List[str], providers: List[str]): +def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - symbol = random.choice(symbols) # noqa: S311 - provider = random.choice(providers) # noqa: S311 - url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" result = requests.get(url, headers=auth_header(), timeout=5) return result.json()["results"] -symbols = ["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "GOOG", "FB", "BABA", "TSM", "V"] -providers = ["fmp", "intrinio", "polygon", "yfinance"] -stocks_data = get_random_data("stocks", symbols=symbols, providers=providers) +data = {} -# TODO : add more crypto providers and symbols -symbols_crypto = ["BTC"] -providers_crypto = ["fmp"] -crypto_data = get_random_data( - menu="crypto", symbols=symbols_crypto, providers=providers_crypto -) + +def get_stocks_data(): + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + return data["stocks_data"] + + +def get_crypto_data(): + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + return data["crypto_data"] @pytest.mark.parametrize( "params", [ - ({"data": stocks_data}), - ({"data": crypto_data}), + ({"data": get_stocks_data()}), + ({"data": get_crypto_data()}), ], ) @pytest.mark.integration @@ -73,8 +84,8 @@ def test_econometrics_corr(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "y_column": "close", "x_columns": ["date"]}), - ({"data": crypto_data, "y_column": "close", "x_columns": ["date"]}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration @@ -98,8 +109,8 @@ def test_econometrics_ols_summary(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "y_column": "volume", "x_columns": ["close"]}), - ({"data": crypto_data, "y_column": "volume", "x_columns": ["close"]}), + ({"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}), + ({"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}), ], ) @pytest.mark.integration @@ -125,7 +136,7 @@ def test_econometrics_dwat(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"], "lags": "", @@ -133,7 +144,7 @@ def test_econometrics_dwat(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"], "lags": "2", @@ -164,13 +175,13 @@ def test_econometrics_bgot(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "columns": ["close", "volume"], } ), ( { - "data": crypto_data, + "data": get_crypto_data(), "columns": ["close", "volume"], } ), @@ -199,7 +210,7 @@ def test_econometrics_coint(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "y_column": "volume", "x_columns": "close", "lag": "", @@ -207,7 +218,7 @@ def test_econometrics_coint(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "y_column": "volume", "x_columns": "close", "lag": "2", @@ -230,8 +241,8 @@ def test_econometrics_granger(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "column": "close", "regression": "c"}), - ({"data": crypto_data, "column": "volume", "regression": "ctt"}), + ({"data": get_stocks_data(), "column": "close", "regression": "c"}), + ({"data": get_crypto_data(), "column": "volume", "regression": "ctt"}), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py index 6ebf3068ec9..39212b293dd 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -1,4 +1,6 @@ """Test econometrics extension.""" +import random + import pytest from openbb_core.app.model.obbject import OBBject @@ -13,14 +15,51 @@ def obb(pytestconfig): return openbb.obb +data = {} + + +def get_stocks_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = openbb.obb.stocks.load( + symbol=symbol, provider=provider + ).results + return data["stocks_data"] + + +def get_crypto_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = openbb.obb.crypto.load( + symbol=symbol, provider=provider + ).results + return data["crypto_data"] + + @pytest.mark.parametrize( "params", [ - ({"data": "", "return": ""}), + ({"data": get_stocks_data()}), + ({"data": get_crypto_data()}), ], ) @pytest.mark.integration def test_econometrics_corr(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.corr(**params) assert result assert isinstance(result, OBBject) @@ -30,11 +69,14 @@ def test_econometrics_corr(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_ols(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.ols(**params) assert result assert isinstance(result, OBBject) @@ -44,11 +86,14 @@ def test_econometrics_ols(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_ols_summary(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.ols_summary(**params) assert result assert isinstance(result, OBBject) @@ -58,39 +103,70 @@ def test_econometrics_ols_summary(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}), + ({"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}), ], ) @pytest.mark.integration def test_econometrics_dwat(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.dwat(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "lags": "", "return": ""}), + ( + { + "data": get_stocks_data(), + "y_column": "volume", + "x_columns": ["close"], + "lags": "", + } + ), + ( + { + "data": get_crypto_data(), + "y_column": "volume", + "x_columns": ["close"], + "lags": "2", + } + ), ], ) @pytest.mark.integration def test_econometrics_bgot(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.bgot(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "columns": "", "return": ""}), + ( + { + "data": get_stocks_data(), + "columns": ["close", "volume"], + } + ), + ( + { + "data": get_crypto_data(), + "columns": ["close", "volume"], + } + ), ], ) @pytest.mark.integration def test_econometrics_coint(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.coint(**params) assert result assert isinstance(result, OBBject) @@ -100,11 +176,28 @@ def test_econometrics_coint(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_column": "", "lag": "", "return": ""}), + ( + { + "data": get_stocks_data(), + "y_column": "volume", + "x_columns": "close", + "lag": "", + } + ), + ( + { + "data": get_crypto_data(), + "y_column": "volume", + "x_columns": "close", + "lag": "2", + } + ), ], ) @pytest.mark.integration def test_econometrics_granger(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.granger(**params) assert result assert isinstance(result, OBBject) @@ -114,25 +207,30 @@ def test_econometrics_granger(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "column": "", "regression": "", "return": ""}), + ({"data": get_stocks_data(), "column": "close", "regression": "c"}), + ({"data": get_crypto_data(), "column": "volume", "regression": "ctt"}), ], ) @pytest.mark.integration def test_econometrics_unitroot(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.unitroot(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelre(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelre(**params) assert result assert isinstance(result, OBBject) @@ -142,11 +240,14 @@ def test_econometrics_panelre(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelbols(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelbols(**params) assert result assert isinstance(result, OBBject) @@ -156,11 +257,14 @@ def test_econometrics_panelbols(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelpols(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelpols(**params) assert result assert isinstance(result, OBBject) @@ -170,11 +274,14 @@ def test_econometrics_panelpols(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelols(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelols(**params) assert result assert isinstance(result, OBBject) @@ -184,11 +291,14 @@ def test_econometrics_panelols(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelfd(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelfd(**params) assert result assert isinstance(result, OBBject) @@ -198,11 +308,14 @@ def test_econometrics_panelfd(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "y_column": "", "x_columns": "", "return": ""}), + ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration def test_econometrics_panelfmac(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.econometrics.panelfmac(**params) assert result assert isinstance(result, OBBject) diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index e967a965c76..566e3d5fd4b 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -28,33 +28,45 @@ def headers(): return h -def get_random_data(menu: str, symbols: List[str], providers: List[str]): +def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - symbol = random.choice(symbols) # noqa: S311 - provider = random.choice(providers) # noqa: S311 url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" result = requests.get(url, headers=auth_header(), timeout=5) return result.json()["results"] -symbols = ["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "GOOG", "FB", "BABA", "TSM", "V"] -providers = ["fmp", "intrinio", "polygon", "yfinance"] -stocks_data = get_random_data("stocks", symbols=symbols, providers=providers) +data = {} -# TODO : add more crypto providers and symbols -symbols_crypto = ["BTC"] -providers_crypto = ["fmp"] -crypto_data = get_random_data( - menu="crypto", symbols=symbols_crypto, providers=providers_crypto -) + +def get_stocks_data(): + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + return data["stocks_data"] + + +def get_crypto_data(): + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + return data["crypto_data"] @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close"}), - ({"data": crypto_data, "target": "high"}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration @@ -72,8 +84,8 @@ def test_qa_normality(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close"}), - ({"data": crypto_data, "target": "high"}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration @@ -93,7 +105,7 @@ def test_qa_capm(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "close", "threshold_start": "", "threshold_end": "", @@ -101,7 +113,7 @@ def test_qa_capm(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "threshold_start": "0.1", "threshold_end": "1.6", @@ -124,8 +136,8 @@ def test_qa_om(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close", "window": "5"}), - ({"data": crypto_data, "target": "high", "window": "10"}), + ({"data": get_stocks_data(), "target": "close", "window": "5"}), + ({"data": get_crypto_data(), "target": "high", "window": "10"}), ], ) @pytest.mark.integration @@ -143,8 +155,22 @@ def test_qa_kurtosis(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close", "fuller_reg": "c", "kpss_reg": "ct"}), - ({"data": stocks_data, "target": "high", "fuller_reg": "ct", "kpss_reg": "c"}), + ( + { + "data": get_stocks_data(), + "target": "close", + "fuller_reg": "c", + "kpss_reg": "ct", + } + ), + ( + { + "data": get_stocks_data(), + "target": "high", + "fuller_reg": "ct", + "kpss_reg": "c", + } + ), ], ) @pytest.mark.integration @@ -162,8 +188,8 @@ def test_qa_unitroot(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close", "rfr": "", "window": ""}), - ({"data": crypto_data, "target": "high", "rfr": "0.5", "window": "250"}), + ({"data": get_stocks_data(), "target": "close", "rfr": "", "window": ""}), + ({"data": get_crypto_data(), "target": "high", "rfr": "0.5", "window": "250"}), ], ) @pytest.mark.integration @@ -183,7 +209,7 @@ def test_qa_sh(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "close", "target_return": "", "window": "", @@ -192,7 +218,7 @@ def test_qa_sh(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "close", "target_return": "0.5", "window": "275", @@ -216,7 +242,7 @@ def test_qa_so(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close", "window": "220"}), + ({"data": get_stocks_data(), "target": "close", "window": "220"}), ], ) @pytest.mark.integration @@ -234,10 +260,17 @@ def test_qa_skew(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close", "window": "10", "quantile_pct": ""}), ( { - "data": crypto_data, + "data": get_stocks_data(), + "target": "close", + "window": "10", + "quantile_pct": "", + } + ), + ( + { + "data": get_crypto_data(), "target": "high", "window": "50", "quantile_pct": "0.6", @@ -260,8 +293,8 @@ def test_qa_quantile(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "close"}), - ({"data": crypto_data, "target": "high"}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/qa/integration/test_qa_python.py b/openbb_platform/extensions/qa/integration/test_qa_python.py index a64330bf5e4..fc36ffd6cfb 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_python.py +++ b/openbb_platform/extensions/qa/integration/test_qa_python.py @@ -1,4 +1,6 @@ """Test qa extension.""" +import random + import pytest from openbb_core.app.model.obbject import OBBject @@ -13,32 +15,70 @@ def obb(pytestconfig): return openbb.obb +data = {} + + +def get_stocks_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = openbb.obb.stocks.load( + symbol=symbol, provider=provider + ).results + return data["stocks_data"] + + +def get_crypto_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = openbb.obb.crypto.load( + symbol=symbol, provider=provider + ).results + return data["crypto_data"] + + @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "return": ""}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration def test_qa_normality(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.normality(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "return": ""}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration def test_qa_capm(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.capm(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( @@ -46,31 +86,42 @@ def test_qa_capm(params, obb): [ ( { - "data": "", - "target": "", + "data": get_stocks_data(), + "target": "close", "threshold_start": "", "threshold_end": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "threshold_start": "0.1", + "threshold_end": "1.6", } ), ], ) @pytest.mark.integration def test_qa_om(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.om(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "window": "", "return": ""}), + ({"data": get_stocks_data(), "target": "close", "window": "5"}), + ({"data": get_crypto_data(), "target": "high", "window": "10"}), ], ) @pytest.mark.integration def test_qa_kurtosis(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.kurtosis(**params) assert result assert isinstance(result, OBBject) @@ -80,28 +131,94 @@ def test_qa_kurtosis(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "fuller_reg": "", "kpss_reg": "", "return": ""}), + ( + { + "data": get_stocks_data(), + "target": "close", + "fuller_reg": "c", + "kpss_reg": "ct", + } + ), + ( + { + "data": get_stocks_data(), + "target": "high", + "fuller_reg": "ct", + "kpss_reg": "c", + } + ), ], ) @pytest.mark.integration def test_qa_unitroot(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.unitroot(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "rfr": "", "window": "", "return": ""}), + ({"data": get_stocks_data(), "target": "close", "rfr": "", "window": ""}), + ({"data": get_crypto_data(), "target": "high", "rfr": "0.5", "window": "250"}), ], ) @pytest.mark.integration def test_qa_sh(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.sh(**params) assert result assert isinstance(result, OBBject) + + +@pytest.mark.parametrize( + "params", + [ + ( + { + "data": get_stocks_data(), + "target": "close", + "target_return": "", + "window": "", + "adjusted": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "close", + "target_return": "0.5", + "window": "275", + "adjusted": "true", + } + ), + ], +) +@pytest.mark.integration +def test_qa_so(params, obb): + params = {p: v for p, v in params.items() if v} + + result = obb.qa.so(**params) + assert result + assert isinstance(result, OBBject) + + +@pytest.mark.parametrize( + "params", + [ + ({"data": get_stocks_data(), "target": "close", "window": "220"}), + ], +) +@pytest.mark.integration +def test_qa_skew(params, obb): + params = {p: v for p, v in params.items() if v} + + result = obb.qa.skew(**params) + assert result + assert isinstance(result, OBBject) assert len(result.results) > 0 @@ -110,46 +227,26 @@ def test_qa_sh(params, obb): [ ( { - "data": "", - "target": "", - "target_return": "", - "window": "", - "adjusted": "", - "return": "", + "data": get_stocks_data(), + "target": "close", + "window": "10", + "quantile_pct": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "window": "50", + "quantile_pct": "0.6", } ), ], ) @pytest.mark.integration -def test_qa_so(params, obb): - result = obb.qa.so(**params) - assert result - assert isinstance(result, OBBject) - assert len(result.results) > 0 - - -@pytest.mark.parametrize( - "params", - [ - ({"data": "", "target": "", "window": "", "return": ""}), - ], -) -@pytest.mark.integration -def test_qa_skew(params, obb): - result = obb.qa.skew(**params) - assert result - assert isinstance(result, OBBject) - assert len(result.results) > 0 - - -@pytest.mark.parametrize( - "params", - [ - ({"data": "", "target": "", "window": "", "quantile_pct": "", "return": ""}), - ], -) -@pytest.mark.integration def test_qa_quantile(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.quantile(**params) assert result assert isinstance(result, OBBject) @@ -159,12 +256,14 @@ def test_qa_quantile(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "target": "", "return": ""}), + ({"data": get_stocks_data(), "target": "close"}), + ({"data": get_crypto_data(), "target": "high"}), ], ) @pytest.mark.integration def test_qa_summary(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.qa.summary(**params) assert result assert isinstance(result, OBBject) - assert len(result.results) > 0 diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 471dcb1d70f..3b500e96e7f 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -28,26 +28,38 @@ def headers(): return h -def get_random_data(menu: str, symbols: List[str], providers: List[str]): +def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - symbol = random.choice(symbols) # noqa: S311 - provider = random.choice(providers) # noqa: S311 url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" result = requests.get(url, headers=auth_header(), timeout=5) return result.json()["results"] -symbols = ["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "GOOG", "FB", "BABA", "TSM", "V"] -providers = ["fmp", "intrinio", "polygon", "yfinance"] -stocks_data = get_random_data("stocks", symbols=symbols, providers=providers) +data = {} -# TODO : add more crypto providers and symbols -symbols_crypto = ["BTC"] -providers_crypto = ["fmp"] -crypto_data = get_random_data( - menu="crypto", symbols=symbols_crypto, providers=providers_crypto -) + +def get_stocks_data(): + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + return data["stocks_data"] + + +def get_crypto_data(): + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + return data["crypto_data"] @pytest.mark.parametrize( @@ -55,7 +67,7 @@ crypto_data = get_random_data( [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "length": "", "mamode": "", @@ -65,7 +77,7 @@ crypto_data = get_random_data( ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "length": "15", "mamode": "rma", @@ -92,7 +104,7 @@ def test_ta_atr(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "close_column": "", "period": "", @@ -102,7 +114,7 @@ def test_ta_atr(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "close_column": "adj_close", "period": "125", @@ -127,8 +139,8 @@ def test_ta_fib(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "offset": ""}), - ({"data": crypto_data, "index": "date", "offset": "1"}), + ({"data": get_stocks_data(), "index": "", "offset": ""}), + ({"data": get_crypto_data(), "index": "date", "offset": "1"}), ], ) @pytest.mark.integration @@ -146,8 +158,8 @@ def test_ta_obv(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "length": "", "signal": ""}), - ({"data": crypto_data, "index": "date", "length": "15", "signal": "2"}), + ({"data": get_stocks_data(), "index": "", "length": "", "signal": ""}), + ({"data": get_crypto_data(), "index": "date", "length": "15", "signal": "2"}), ], ) @pytest.mark.integration @@ -165,10 +177,10 @@ def test_ta_fisher(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "fast": "", "slow": "", "offset": ""}), + ({"data": get_stocks_data(), "index": "", "fast": "", "slow": "", "offset": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "fast": "5", "slow": "15", @@ -194,7 +206,7 @@ def test_ta_adosc(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "", "index": "", "length": "", @@ -205,7 +217,7 @@ def test_ta_adosc(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "55", @@ -231,10 +243,10 @@ def test_ta_bbands(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "", "index": "", "length": "", "offset": ""}), + ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "55", @@ -258,10 +270,10 @@ def test_ta_zlma(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "length": "", "scalar": ""}), + ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "length": "30", "scalar": "110", @@ -284,10 +296,10 @@ def test_ta_aroon(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "", "index": "", "length": "", "offset": ""}), + ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "55", @@ -313,7 +325,7 @@ def test_ta_sma(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "target": "", "show_all": "", @@ -323,7 +335,7 @@ def test_ta_sma(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "target": "high", "show_all": "true", @@ -348,8 +360,8 @@ def test_ta_demark(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "anchor": "", "offset": ""}), - ({"data": crypto_data, "index": "date", "anchor": "W", "offset": "5"}), + ({"data": get_stocks_data(), "index": "", "anchor": "", "offset": ""}), + ({"data": get_crypto_data(), "index": "date", "anchor": "W", "offset": "5"}), ], ) @pytest.mark.integration @@ -369,7 +381,7 @@ def test_ta_vwap(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "", "index": "", "fast": "", @@ -379,7 +391,7 @@ def test_ta_vwap(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "fast": "10", @@ -404,10 +416,10 @@ def test_ta_macd(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "", "index": "", "length": "", "offset": ""}), + ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "55", @@ -433,7 +445,7 @@ def test_ta_hma(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "lower_length": "", "upper_length": "", @@ -442,7 +454,7 @@ def test_ta_hma(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "lower_length": "30", "upper_length": "40", @@ -468,7 +480,7 @@ def test_ta_donchian(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "conversion": "", "base": "", @@ -479,7 +491,7 @@ def test_ta_donchian(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "conversion": "10", "base": "30", @@ -505,8 +517,8 @@ def test_ta_ichimoku(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "target": "", "period": ""}), - ({"data": crypto_data, "index": "date", "target": "close", "period": "95"}), + ({"data": get_stocks_data(), "index": "", "target": "", "period": ""}), + ({"data": get_crypto_data(), "index": "date", "target": "close", "period": "95"}), ], ) @pytest.mark.integration @@ -524,8 +536,8 @@ def test_ta_clenow(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "offset": ""}), - ({"data": crypto_data, "index": "date", "offset": "5"}), + ({"data": get_stocks_data(), "index": "", "offset": ""}), + ({"data": get_crypto_data(), "index": "date", "offset": "5"}), ], ) @pytest.mark.integration @@ -543,10 +555,10 @@ def test_ta_ad(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "length": "", "scalar": "", "drift": ""}), + ({"data": get_stocks_data(), "index": "", "length": "", "scalar": "", "drift": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "length": "60", "scalar": "90.0", @@ -570,10 +582,10 @@ def test_ta_adx(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "target": "", "index": "", "length": "", "offset": ""}), + ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "60", @@ -597,8 +609,8 @@ def test_ta_wma(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "length": "", "scalar": ""}), - ({"data": crypto_data, "index": "date", "length": "16", "scalar": "0.02"}), + ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ({"data": get_crypto_data(), "index": "date", "length": "16", "scalar": "0.02"}), ], ) @pytest.mark.integration @@ -618,7 +630,7 @@ def test_ta_cci(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "", "index": "", "length": "", @@ -628,7 +640,7 @@ def test_ta_cci(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "date", "length": "16", @@ -655,7 +667,7 @@ def test_ta_rsi(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "fast_k_period": "", "slow_d_period": "", @@ -664,7 +676,7 @@ def test_ta_rsi(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "fast_k_period": "12", "slow_d_period": "2", @@ -690,7 +702,7 @@ def test_ta_stoch(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "length": "", "scalar": "", @@ -700,7 +712,7 @@ def test_ta_stoch(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "length": "22", "scalar": "24", @@ -725,8 +737,8 @@ def test_ta_kc(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": stocks_data, "index": "", "length": ""}), - ({"data": crypto_data, "index": "date", "length": "20"}), + ({"data": get_stocks_data(), "index": "", "length": ""}), + ({"data": get_crypto_data(), "index": "date", "length": "20"}), ], ) @pytest.mark.integration @@ -746,7 +758,7 @@ def test_ta_cg(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "index": "", "lower_q": "", "upper_q": "", @@ -756,7 +768,7 @@ def test_ta_cg(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "index": "date", "lower_q": "0.3", "upper_q": "0.7", @@ -783,7 +795,7 @@ def test_ta_cones(params, headers): [ ( { - "data": stocks_data, + "data": get_stocks_data(), "target": "close", "index": "date", "length": "", @@ -792,7 +804,7 @@ def test_ta_cones(params, headers): ), ( { - "data": crypto_data, + "data": get_crypto_data(), "target": "high", "index": "", "length": "60", diff --git a/openbb_platform/extensions/ta/integration/test_ta_python.py b/openbb_platform/extensions/ta/integration/test_ta_python.py index ca9d5dd3bee..376688ca86e 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_python.py +++ b/openbb_platform/extensions/ta/integration/test_ta_python.py @@ -1,4 +1,6 @@ """Test ta extension.""" +import random + import pytest from openbb_core.app.model.obbject import OBBject @@ -13,24 +15,69 @@ def obb(pytestconfig): return openbb.obb +data = {} + + +def get_stocks_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "stocks_data" in data: + return data["stocks_data"] + + symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 + provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 + + data["stocks_data"] = openbb.obb.stocks.load( + symbol=symbol, provider=provider + ).results + return data["stocks_data"] + + +def get_crypto_data(): + import openbb # pylint:disable=import-outside-toplevel + + if "crypto_data" in data: + return data["crypto_data"] + + # TODO : add more crypto providers and symbols + symbol = random.choice(["BTC"]) # noqa: S311 + provider = random.choice(["fmp"]) # noqa: S311 + + data["crypto_data"] = openbb.obb.crypto.load( + symbol=symbol, provider=provider + ).results + return data["crypto_data"] + + @pytest.mark.parametrize( "params", [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "length": "", "mamode": "", "drift": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "15", + "mamode": "rma", + "drift": "2", + "offset": "1", } ), ], ) @pytest.mark.integration def test_ta_atr(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.atr(**params) assert result assert isinstance(result, OBBject) @@ -42,19 +89,30 @@ def test_ta_atr(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "close_column": "", "period": "", "start_date": "", "end_date": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "close_column": "adj_close", + "period": "125", + "start_date": "", + "end_date": "", } ), ], ) @pytest.mark.integration def test_ta_fib(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.fib(**params) assert result assert isinstance(result, OBBject) @@ -64,11 +122,14 @@ def test_ta_fib(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "offset": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "offset": ""}), + ({"data": get_crypto_data(), "index": "date", "offset": "1"}), ], ) @pytest.mark.integration def test_ta_obv(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.obv(**params) assert result assert isinstance(result, OBBject) @@ -78,11 +139,14 @@ def test_ta_obv(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "length": "", "signal": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "length": "", "signal": ""}), + ({"data": get_crypto_data(), "index": "date", "length": "15", "signal": "2"}), ], ) @pytest.mark.integration def test_ta_fisher(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.fisher(**params) assert result assert isinstance(result, OBBject) @@ -92,11 +156,30 @@ def test_ta_fisher(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "fast": "", "slow": "", "offset": "", "return": ""}), + ( + { + "data": get_stocks_data(), + "index": "", + "fast": "", + "slow": "", + "offset": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "fast": "5", + "slow": "15", + "offset": "2", + } + ), ], ) @pytest.mark.integration def test_ta_adosc(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.adosc(**params) assert result assert isinstance(result, OBBject) @@ -108,20 +191,32 @@ def test_ta_adosc(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "std": "", "mamode": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "55", + "std": "3", + "mamode": "wma", + "offset": "1", } ), ], ) @pytest.mark.integration def test_ta_bbands(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.bbands(**params) assert result assert isinstance(result, OBBject) @@ -133,18 +228,28 @@ def test_ta_bbands(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "55", + "offset": "5", } ), ], ) @pytest.mark.integration def test_ta_zlma(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.zlma(**params) assert result assert isinstance(result, OBBject) @@ -154,11 +259,21 @@ def test_ta_zlma(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "length": "", "scalar": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "30", + "scalar": "110", + } + ), ], ) @pytest.mark.integration def test_ta_aroon(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.aroon(**params) assert result assert isinstance(result, OBBject) @@ -170,18 +285,28 @@ def test_ta_aroon(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "55", + "offset": "2", } ), ], ) @pytest.mark.integration def test_ta_sma(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.sma(**params) assert result assert isinstance(result, OBBject) @@ -193,19 +318,30 @@ def test_ta_sma(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "target": "", "show_all": "", "asint": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "target": "high", + "show_all": "true", + "asint": "true", + "offset": "5", } ), ], ) @pytest.mark.integration def test_ta_demark(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.demark(**params) assert result assert isinstance(result, OBBject) @@ -215,11 +351,14 @@ def test_ta_demark(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "anchor": "", "offset": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "anchor": "", "offset": ""}), + ({"data": get_crypto_data(), "index": "date", "anchor": "W", "offset": "5"}), ], ) @pytest.mark.integration def test_ta_vwap(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.vwap(**params) assert result assert isinstance(result, OBBject) @@ -231,19 +370,30 @@ def test_ta_vwap(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "fast": "", "slow": "", "signal": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "fast": "10", + "slow": "30", + "signal": "10", } ), ], ) @pytest.mark.integration def test_ta_macd(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.macd(**params) assert result assert isinstance(result, OBBject) @@ -255,18 +405,28 @@ def test_ta_macd(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "55", + "offset": "2", } ), ], ) @pytest.mark.integration def test_ta_hma(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.hma(**params) assert result assert isinstance(result, OBBject) @@ -278,18 +438,28 @@ def test_ta_hma(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "lower_length": "", "upper_length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "lower_length": "30", + "upper_length": "40", + "offset": "5", } ), ], ) @pytest.mark.integration def test_ta_donchian(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.donchian(**params) assert result assert isinstance(result, OBBject) @@ -301,20 +471,32 @@ def test_ta_donchian(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "conversion": "", "base": "", "lagging": "", "offset": "", "lookahead": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "conversion": "10", + "base": "30", + "lagging": "50", + "offset": "30", + "lookahead": "true", } ), ], ) @pytest.mark.integration def test_ta_ichimoku(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.ichimoku(**params) assert result assert isinstance(result, OBBject) @@ -324,11 +506,21 @@ def test_ta_ichimoku(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "target": "", "period": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "target": "", "period": ""}), + ( + { + "data": get_crypto_data(), + "index": "date", + "target": "close", + "period": "95", + } + ), ], ) @pytest.mark.integration def test_ta_clenow(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.clenow(**params) assert result assert isinstance(result, OBBject) @@ -340,18 +532,28 @@ def test_ta_clenow(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "length": "", "scalar": "", "drift": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "60", + "scalar": "90.0", + "drift": "2", } ), ], ) @pytest.mark.integration def test_ta_adx(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.adx(**params) assert result assert isinstance(result, OBBject) @@ -363,18 +565,28 @@ def test_ta_adx(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "60", + "offset": "10", } ), ], ) @pytest.mark.integration def test_ta_wma(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.wma(**params) assert result assert isinstance(result, OBBject) @@ -384,11 +596,21 @@ def test_ta_wma(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "length": "", "scalar": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "16", + "scalar": "0.02", + } + ), ], ) @pytest.mark.integration def test_ta_cci(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.cci(**params) assert result assert isinstance(result, OBBject) @@ -400,19 +622,30 @@ def test_ta_cci(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "target": "", "index": "", "length": "", "scalar": "", "drift": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "date", + "length": "16", + "scalar": "90.0", + "drift": "2", } ), ], ) @pytest.mark.integration def test_ta_rsi(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.rsi(**params) assert result assert isinstance(result, OBBject) @@ -424,18 +657,28 @@ def test_ta_rsi(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "fast_k_period": "", "slow_d_period": "", "slow_k_period": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "fast_k_period": "12", + "slow_d_period": "2", + "slow_k_period": "2", } ), ], ) @pytest.mark.integration def test_ta_stoch(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.stoch(**params) assert result assert isinstance(result, OBBject) @@ -447,19 +690,30 @@ def test_ta_stoch(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "length": "", "scalar": "", "mamode": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "22", + "scalar": "24", + "mamode": "sma", + "offset": "5", } ), ], ) @pytest.mark.integration def test_ta_kc(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.kc(**params) assert result assert isinstance(result, OBBject) @@ -469,11 +723,14 @@ def test_ta_kc(params, obb): @pytest.mark.parametrize( "params", [ - ({"data": "", "index": "", "length": "", "return": ""}), + ({"data": get_stocks_data(), "index": "", "length": ""}), + ({"data": get_crypto_data(), "index": "date", "length": "20"}), ], ) @pytest.mark.integration def test_ta_cg(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.cg(**params) assert result assert isinstance(result, OBBject) @@ -485,19 +742,30 @@ def test_ta_cg(params, obb): [ ( { - "data": "", + "data": get_stocks_data(), "index": "", "lower_q": "", "upper_q": "", "model": "", "is_crypto": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "index": "date", + "lower_q": "0.3", + "upper_q": "0.7", + "model": "Parkinson", + "is_crypto": "true", } ), ], ) @pytest.mark.integration def test_ta_cones(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.cones(**params) assert result assert isinstance(result, OBBject) @@ -509,18 +777,28 @@ def test_ta_cones(params, obb): [ ( { - "data": "", - "target": "", - "index": "", + "data": get_stocks_data(), + "target": "close", + "index": "date", "length": "", "offset": "", - "return": "", + } + ), + ( + { + "data": get_crypto_data(), + "target": "high", + "index": "", + "length": "60", + "offset": "10", } ), ], ) @pytest.mark.integration def test_ta_ema(params, obb): + params = {p: v for p, v in params.items() if v} + result = obb.ta.ema(**params) assert result assert isinstance(result, OBBject) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_generator.py index 8605d0a539d..2e2ed72280d 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_generator.py @@ -15,6 +15,8 @@ TEST_TEMPLATE = """\n\n@pytest.mark.parametrize( ) @pytest.mark.integration def test_{test_name}(params, obb): + params = {{p: v for p, v in params.items() if v}} + result = obb.{command_name}(**params) assert result assert isinstance(result, OBBject) @@ -194,6 +196,8 @@ def write_test_data_processing( test_name, full_command = get_full_command_name_and_test_name(route=route) hints = get_type_hints(commands_map[route]) + hints.pop("cc", None) + hints.pop("return", None) test_params_list = [{k: "" for k in get_test_params_data_processing(hints)}] write_to_file_w_template( From d1f4450503c398f83382498f262b314dd0c5bb64 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 18:58:05 +0200 Subject: [PATCH 12/45] Cleanup --- ...tests.py => test_integration_tests_api.py} | 15 +---------- .../tests/test_integration_tests_python.py | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+), 14 deletions(-) rename openbb_platform/extensions/tests/{test_integration_tests.py => test_integration_tests_api.py} (64%) create mode 100644 openbb_platform/extensions/tests/test_integration_tests_python.py diff --git a/openbb_platform/extensions/tests/test_integration_tests.py b/openbb_platform/extensions/tests/test_integration_tests_api.py similarity index 64% rename from openbb_platform/extensions/tests/test_integration_tests.py rename to openbb_platform/extensions/tests/test_integration_tests_api.py index 6878c705c1d..d113a0eef90 100644 --- a/openbb_platform/extensions/tests/test_integration_tests.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -16,17 +16,7 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) -def test_python_interface_integration_tests() -> None: - """Test if there are any missing providers for integration tests.""" - run_test("unit", check_missing_integration_test_providers) - - -def test_python_interface_integration_test_params() -> None: - """Test if there are any missing params for integration tests.""" - run_test("unit", check_missing_integration_test_params) - - -def test_api_interface_integration_tests() -> None: +def test_api_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("integration", check_missing_integration_test_providers) @@ -34,6 +24,3 @@ def test_api_interface_integration_tests() -> None: def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("integration", check_missing_integration_test_params) - - -test_python_interface_integration_test_params() diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py new file mode 100644 index 00000000000..239297d44da --- /dev/null +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -0,0 +1,26 @@ +"""Test the integration tests.""" +from extensions.tests.utils.integration_tests_testers import ( + check_missing_integration_test_params, + check_missing_integration_test_providers, + get_integration_tests, + get_module_functions, +) + + +def run_test(test_type: str, check_function) -> None: + """Run tests helper function.""" + integration_tests = get_integration_tests(test_type=test_type) + functions = get_module_functions(integration_tests) + missing_items = check_function(functions) + + assert not missing_items, "\n".join(missing_items) + + +def test_python_interface_integration_test_providers() -> None: + """Test if there are any missing providers for integration tests.""" + run_test("unit", check_missing_integration_test_providers) + + +def test_python_interface_integration_test_params() -> None: + """Test if there are any missing params for integration tests.""" + run_test("unit", check_missing_integration_test_params) From b06e9da721b27fd39567932bb54e7b15bf448719 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 21:46:06 +0200 Subject: [PATCH 13/45] Lint and skip --- noxfile.py | 1 + .../integration/test_econometrics_api.py | 1 - .../extensions/qa/integration/test_qa_api.py | 1 - .../extensions/ta/integration/test_ta_api.py | 79 ++++++++++++++++--- .../tests/test_integration_tests_api.py | 3 + .../utils/integration_tests_generator.py | 4 +- 6 files changed, 76 insertions(+), 13 deletions(-) diff --git a/noxfile.py b/noxfile.py index 7acd1a4fcb6..66f4b95e2aa 100644 --- a/noxfile.py +++ b/noxfile.py @@ -4,6 +4,7 @@ test_locations = [ "openbb_platform/tests", "openbb_platform/platform", "openbb_platform/providers", + "openbb_platform/extensions", ] diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index bf7f0b88343..e8871463163 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -1,6 +1,5 @@ import json import random -from typing import List import pytest import requests diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index 566e3d5fd4b..ae470fddae5 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -1,6 +1,5 @@ import json import random -from typing import List import pytest import requests diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 3b500e96e7f..25bcb1b90fd 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -1,6 +1,5 @@ import json import random -from typing import List import pytest import requests @@ -177,7 +176,15 @@ def test_ta_fisher(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "index": "", "fast": "", "slow": "", "offset": ""}), + ( + { + "data": get_stocks_data(), + "index": "", + "fast": "", + "slow": "", + "offset": "", + } + ), ( { "data": get_crypto_data(), @@ -243,7 +250,15 @@ def test_ta_bbands(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), + ( + { + "data": get_stocks_data(), + "target": "", + "index": "", + "length": "", + "offset": "", + } + ), ( { "data": get_crypto_data(), @@ -296,7 +311,15 @@ def test_ta_aroon(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), + ( + { + "data": get_stocks_data(), + "target": "", + "index": "", + "length": "", + "offset": "", + } + ), ( { "data": get_crypto_data(), @@ -416,7 +439,15 @@ def test_ta_macd(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), + ( + { + "data": get_stocks_data(), + "target": "", + "index": "", + "length": "", + "offset": "", + } + ), ( { "data": get_crypto_data(), @@ -518,7 +549,14 @@ def test_ta_ichimoku(params, headers): "params", [ ({"data": get_stocks_data(), "index": "", "target": "", "period": ""}), - ({"data": get_crypto_data(), "index": "date", "target": "close", "period": "95"}), + ( + { + "data": get_crypto_data(), + "index": "date", + "target": "close", + "period": "95", + } + ), ], ) @pytest.mark.integration @@ -555,7 +593,15 @@ def test_ta_ad(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "index": "", "length": "", "scalar": "", "drift": ""}), + ( + { + "data": get_stocks_data(), + "index": "", + "length": "", + "scalar": "", + "drift": "", + } + ), ( { "data": get_crypto_data(), @@ -582,7 +628,15 @@ def test_ta_adx(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "target": "", "index": "", "length": "", "offset": ""}), + ( + { + "data": get_stocks_data(), + "target": "", + "index": "", + "length": "", + "offset": "", + } + ), ( { "data": get_crypto_data(), @@ -610,7 +664,14 @@ def test_ta_wma(params, headers): "params", [ ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), - ({"data": get_crypto_data(), "index": "date", "length": "16", "scalar": "0.02"}), + ( + { + "data": get_crypto_data(), + "index": "date", + "length": "16", + "scalar": "0.02", + } + ), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index d113a0eef90..60214392308 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,4 +1,5 @@ """Test the integration tests.""" +import pytest from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, @@ -16,11 +17,13 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) +@pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") def test_api_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("integration", check_missing_integration_test_providers) +@pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("integration", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_generator.py index 1d02868d312..2e2ed72280d 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_generator.py @@ -1,9 +1,9 @@ """Integration test generator.""" from pathlib import Path, PosixPath -from platform.core.openbb_core.app.provider_interface import ProviderInterface -from platform.core.openbb_core.app.router import CommandMap from typing import Any, Dict, List, Literal, Tuple, Type, get_origin, get_type_hints +from openbb_core.app.provider_interface import ProviderInterface +from openbb_core.app.router import CommandMap from pydantic.fields import FieldInfo from pydantic_core import PydanticUndefined From 66dbb9a1dfda962663d4f68c7f7533a2ffad37b1 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 22:16:54 +0200 Subject: [PATCH 14/45] Cleanup --- .../tests/test_integration_tests_api.py | 4 ++-- .../tests/test_integration_tests_python.py | 4 ++-- .../tests/utils/integration_tests_testers.py | 15 +++++++++------ 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 60214392308..5904328a821 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -20,10 +20,10 @@ def run_test(test_type: str, check_function) -> None: @pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") def test_api_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" - run_test("integration", check_missing_integration_test_providers) + run_test("api", check_missing_integration_test_providers) @pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" - run_test("integration", check_missing_integration_test_params) + run_test("api", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 239297d44da..0575ebdc64e 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -18,9 +18,9 @@ def run_test(test_type: str, check_function) -> None: def test_python_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" - run_test("unit", check_missing_integration_test_providers) + run_test("python", check_missing_integration_test_providers) def test_python_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" - run_test("unit", check_missing_integration_test_params) + run_test("python", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index f0b820b53f5..3ec0e0de4a2 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -12,13 +12,13 @@ from openbb_core.app.provider_interface import ProviderInterface from openbb_core.app.router import CommandMap -def get_integration_tests(test_type: Literal["integration", "unit"]) -> List[Any]: +def get_integration_tests(test_type: Literal["api", "python"]) -> List[Any]: """Get integration tests for the OpenBB Platform.""" integration_tests: List[Any] = [] - if test_type == "unit": + if test_type == "python": file_end = "_python.py" - elif test_type == "integration": + elif test_type == "api": file_end = "_api.py" for extension in find_extensions(): @@ -112,9 +112,11 @@ def check_missing_params( if isinstance(command_params, list): for expected_param in command_params[0]: if expected_param not in test_params.keys(): - missing_params.append( - f"Missing param {expected_param} in function {function}" - ) + # if return is the expected param, we can ignore + if expected_param != "return": + missing_params.append( + f"Missing param {expected_param} in function {function}" + ) return missing_params @@ -170,6 +172,7 @@ def check_integration_tests( missing_items = check_function( processing_command_params, function_params, function, True ) + all_missing_items.extend(missing_items) return all_missing_items From 46f17be1a84d741985d5cbfcb63f69ce33c113de Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:12:03 +0200 Subject: [PATCH 15/45] Working tests --- .../extensions/tests/test_integration_tests_api.py | 5 +++-- .../tests/test_integration_tests_python.py | 4 ++++ .../tests/utils/integration_tests_api_generator.py | 2 +- .../tests/utils/integration_tests_testers.py | 13 +++++++------ 4 files changed, 15 insertions(+), 9 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 5904328a821..e82ba079339 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -17,13 +17,14 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) -@pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") +# TODO: Check if this can work without being an integration test +@pytest.mark.integration def test_api_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("api", check_missing_integration_test_providers) -@pytest.mark.skip(reason="Needs uvicorn to be launched but shouldn't be the case.") +@pytest.mark.integration def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("api", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 0575ebdc64e..1303b8ed62b 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,4 +1,5 @@ """Test the integration tests.""" +import pytest from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, @@ -16,11 +17,14 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) +# TODO: Check if this can work without being an integration test +@pytest.mark.integration def test_python_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("python", check_missing_integration_test_providers) +@pytest.mark.integration def test_python_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("python", check_missing_integration_test_params) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index a69cd915f81..d64cf2ab7de 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -132,7 +132,7 @@ def write_integration_tests( if __name__ == "__main__": - r = requests.get("http://0.0.0.0:8000/openapi.json", timeout=5).json() + r = requests.get("http://0.0.0.0:8000/openapi.json", timeout=10).json() if not r: raise Exception("Could not get openapi.json") diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 3ec0e0de4a2..3de971d777a 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -111,12 +111,13 @@ def check_missing_params( for test_params in function_params: if isinstance(command_params, list): for expected_param in command_params[0]: - if expected_param not in test_params.keys(): - # if return is the expected param, we can ignore - if expected_param != "return": - missing_params.append( - f"Missing param {expected_param} in function {function}" - ) + if ( + expected_param not in test_params.keys() + and expected_param != "return" + ): + missing_params.append( + f"Missing param {expected_param} in function {function}" + ) return missing_params From 9cad7c8b6bf5bc680d70695e0edfc7eba933d8e1 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Wed, 4 Oct 2023 23:23:37 +0200 Subject: [PATCH 16/45] Revert nox file --- noxfile.py | 1 - 1 file changed, 1 deletion(-) diff --git a/noxfile.py b/noxfile.py index 66f4b95e2aa..7acd1a4fcb6 100644 --- a/noxfile.py +++ b/noxfile.py @@ -4,7 +4,6 @@ test_locations = [ "openbb_platform/tests", "openbb_platform/platform", "openbb_platform/providers", - "openbb_platform/extensions", ] From fcb5d2d6060dffcb4ebb4705921e6dc877ae7755 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Thu, 5 Oct 2023 13:38:44 +0200 Subject: [PATCH 17/45] QA of QA tests pass with @the-praxs --- .../crypto/integration/test_crypto_api.py | 6 +- .../crypto/integration/test_crypto_python.py | 2 + .../integration/test_econometrics_api.py | 22 +- .../integration/test_econometrics_python.py | 4 +- .../economy/integration/test_economy_api.py | 37 ++-- .../integration/test_economy_python.py | 4 + .../integration/test_fixedincome_api.py | 20 +- .../forex/integration/test_forex_api.py | 18 +- .../forex/integration/test_forex_python.py | 20 +- .../futures/integration/test_futures_api.py | 12 +- .../integration/test_futures_python.py | 2 + .../news/integration/test_news_api.py | 16 +- .../news/integration/test_news_python.py | 12 ++ .../extensions/qa/integration/test_qa_api.py | 22 +- .../stocks/integration/test_stocks_api.py | 198 ++++++++++++++---- .../stocks/integration/test_stocks_python.py | 134 ++++++++++-- .../extensions/ta/integration/test_ta_api.py | 56 ++--- .../utils/integration_tests_api_generator.py | 6 +- 18 files changed, 436 insertions(+), 155 deletions(-) diff --git a/openbb_platform/extensions/crypto/integration/test_crypto_api.py b/openbb_platform/extensions/crypto/integration/test_crypto_api.py index 54d67068e31..8bec440e201 100644 --- a/openbb_platform/extensions/crypto/integration/test_crypto_api.py +++ b/openbb_platform/extensions/crypto/integration/test_crypto_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -28,6 +28,7 @@ def headers(): "symbol": "BTCUSD", "start_date": "2023-01-01", "end_date": "2023-01-02", + "timeseries": 1, } ), ( @@ -37,6 +38,7 @@ def headers(): "symbol": "BTCUSD", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( @@ -93,6 +95,6 @@ def test_crypto_load(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/crypto/load?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/crypto/integration/test_crypto_python.py b/openbb_platform/extensions/crypto/integration/test_crypto_python.py index 7df073d0ac0..f621443a166 100644 --- a/openbb_platform/extensions/crypto/integration/test_crypto_python.py +++ b/openbb_platform/extensions/crypto/integration/test_crypto_python.py @@ -31,6 +31,7 @@ def obb(pytestconfig): "symbol": "BTCUSD", "start_date": "2023-01-01", "end_date": "2023-01-02", + "timeseries": 1, } ), ( @@ -40,6 +41,7 @@ def obb(pytestconfig): "symbol": "BTCUSD", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index e8871463163..482e070fb65 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -10,7 +10,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -31,7 +31,7 @@ def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=5) + result = requests.get(url, headers=auth_header(), timeout=10) return result.json()["results"] @@ -75,7 +75,7 @@ def test_econometrics_corr(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/corr?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -100,7 +100,7 @@ def test_econometrics_ols_summary(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/ols_summary?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=body) + result = requests.post(url, headers=headers, timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -125,7 +125,7 @@ def test_econometrics_dwat(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/dwat?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=body) + result = requests.post(url, headers=headers, timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -164,7 +164,7 @@ def test_econometrics_bgot(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/bgot?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=body) + result = requests.post(url, headers=headers, timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -199,7 +199,7 @@ def test_econometrics_coint(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/coint?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=body) + result = requests.post(url, headers=headers, timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -211,7 +211,7 @@ def test_econometrics_coint(params, headers): { "data": get_stocks_data(), "y_column": "volume", - "x_columns": "close", + "x_column": "close", "lag": "", } ), @@ -219,7 +219,7 @@ def test_econometrics_coint(params, headers): { "data": get_crypto_data(), "y_column": "volume", - "x_columns": "close", + "x_column": "close", "lag": "2", } ), @@ -232,7 +232,7 @@ def test_econometrics_granger(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/granger?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -251,6 +251,6 @@ def test_econometrics_unitroot(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/unitroot?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py index 39212b293dd..ee6d32e0fea 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -180,7 +180,7 @@ def test_econometrics_coint(params, obb): { "data": get_stocks_data(), "y_column": "volume", - "x_columns": "close", + "x_column": "close", "lag": "", } ), @@ -188,7 +188,7 @@ def test_econometrics_coint(params, obb): { "data": get_crypto_data(), "y_column": "volume", - "x_columns": "close", + "x_column": "close", "lag": "2", } ), diff --git a/openbb_platform/extensions/economy/integration/test_economy_api.py b/openbb_platform/extensions/economy/integration/test_economy_api.py index 2c22d197ea5..d7e98bf85ce 100644 --- a/openbb_platform/extensions/economy/integration/test_economy_api.py +++ b/openbb_platform/extensions/economy/integration/test_economy_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -27,7 +27,7 @@ def test_economy_const(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/const?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -53,7 +53,7 @@ def test_economy_cpi(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/cpi?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -87,6 +87,7 @@ def test_economy_cpi(params, headers): "symbol": "^DJI", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( @@ -96,6 +97,7 @@ def test_economy_cpi(params, headers): "symbol": "^DJI", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( @@ -156,7 +158,7 @@ def test_economy_index(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/index?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -191,7 +193,7 @@ def test_economy_european_index(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/european_index?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -206,14 +208,19 @@ def test_economy_european_index_constituents(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/european_index_constituents?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( "params", - [({}), ({"europe": True, "provider": "cboe"})], + [ + ({}), + ({"europe": True, "provider": "cboe"}), + ({"provider": "fmp"}), + ({"provider": "yfinance"}), + ], ) @pytest.mark.integration def test_economy_available_indices(params, headers): @@ -221,7 +228,7 @@ def test_economy_available_indices(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/available_indices?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -236,7 +243,7 @@ def test_economy_risk(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/risk?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -261,7 +268,7 @@ def test_economy_index_search(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/index_search?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -276,7 +283,7 @@ def test_economy_index_snapshots(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/index_snapshots?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -291,7 +298,7 @@ def test_economy_cot_search(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/cot_search?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -321,7 +328,7 @@ def test_economy_cot(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/cot?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -346,7 +353,7 @@ def test_economy_sp500_multiples(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/sp500_multiples?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -370,6 +377,6 @@ def test_economy_fred_index(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/economy/fred_index?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/economy/integration/test_economy_python.py b/openbb_platform/extensions/economy/integration/test_economy_python.py index 78b967dfffe..a5d8ab147fb 100644 --- a/openbb_platform/extensions/economy/integration/test_economy_python.py +++ b/openbb_platform/extensions/economy/integration/test_economy_python.py @@ -86,6 +86,7 @@ def test_economy_cpi(params): "symbol": "^DJI", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( @@ -95,6 +96,7 @@ def test_economy_cpi(params): "symbol": "^DJI", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( @@ -214,6 +216,8 @@ def test_economy_european_index_constituents(params): [ ({}), ({"europe": True, "provider": "cboe"}), + ({"provider": "fmp"}), + ({"provider": "yfinance"}), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py index 3a96790948c..cb750ba3fa3 100644 --- a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py +++ b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -27,7 +27,7 @@ def test_fixedincome_treasury(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/treasury?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -42,7 +42,7 @@ def test_fixedincome_ycrv(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/ycrv?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -67,7 +67,7 @@ def test_fixedincome_sofr(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/sofr?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -92,7 +92,7 @@ def test_fixedincome_estr(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/estr?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -117,7 +117,7 @@ def test_fixedincome_sonia(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/sonia?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -142,7 +142,7 @@ def test_fixedincome_ameribor(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/ameribor?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -167,7 +167,7 @@ def test_fixedincome_fed(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/fed?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -182,7 +182,7 @@ def test_fixedincome_projections(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/projections?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -197,6 +197,6 @@ def test_fixedincome_iorb(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/fixedincome/iorb?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/forex/integration/test_forex_api.py b/openbb_platform/extensions/forex/integration/test_forex_api.py index fa2880bbdb4..c1438b736a6 100644 --- a/openbb_platform/extensions/forex/integration/test_forex_api.py +++ b/openbb_platform/extensions/forex/integration/test_forex_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -33,6 +33,16 @@ def headers(): "provider": "polygon", } ), + ( + { + "provider": "fmp", + } + ), + ( + { + "provider": "intrinio", + } + ), ], ) @pytest.mark.integration @@ -41,7 +51,7 @@ def test_forex_pairs(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/forex/pairs?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -62,7 +72,7 @@ def test_forex_pairs(params, headers): ( { "interval": "1day", - "provider": "fmp", + "provider": "intrinio", "symbol": "EURUSD", "start_date": "2023-01-01", "end_date": "2023-06-06", @@ -122,6 +132,6 @@ def test_forex_load(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/forex/load?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/forex/integration/test_forex_python.py b/openbb_platform/extensions/forex/integration/test_forex_python.py index 710858406ff..5d2beb30d5e 100644 --- a/openbb_platform/extensions/forex/integration/test_forex_python.py +++ b/openbb_platform/extensions/forex/integration/test_forex_python.py @@ -31,6 +31,16 @@ def obb(pytestconfig): "provider": "polygon", } ), + ( + { + "provider": "fmp", + } + ), + ( + { + "provider": "intrinio", + } + ), ], ) @pytest.mark.integration @@ -44,13 +54,7 @@ def test_forex_pairs(params, obb): @pytest.mark.parametrize( "params", [ - ( - { - "symbol": "EURUSD", - "start_date": "2023-01-01", - "end_date": "2023-06-06", - } - ), + ({"symbol": "EURUSD", "start_date": "2023-01-01", "end_date": "2023-06-06"}), ( { "interval": "1min", @@ -63,7 +67,7 @@ def test_forex_pairs(params, obb): ( { "interval": "1day", - "provider": "fmp", + "provider": "intrinio", "symbol": "EURUSD", "start_date": "2023-01-01", "end_date": "2023-06-06", diff --git a/openbb_platform/extensions/futures/integration/test_futures_api.py b/openbb_platform/extensions/futures/integration/test_futures_api.py index 2cd5d3638c6..99fdff6096b 100644 --- a/openbb_platform/extensions/futures/integration/test_futures_api.py +++ b/openbb_platform/extensions/futures/integration/test_futures_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -50,14 +50,18 @@ def test_futures_load(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/futures/load?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( "params", - [({"symbol": "AAPL", "date": "2023-01-01"})], + [ + ({"symbol": "AAPL", "date": "2023-01-01"}), + ({"provider": "cboe", "symbol": "AAPL", "date": "2023-01-01"}), + ({"provider": "yfinance", "symbol": "AAPL", "date": "2023-01-01"}), + ], ) @pytest.mark.integration def test_futures_curve(params, headers): @@ -65,6 +69,6 @@ def test_futures_curve(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/futures/curve?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/futures/integration/test_futures_python.py b/openbb_platform/extensions/futures/integration/test_futures_python.py index fef638d86f1..b04a4b6ef53 100644 --- a/openbb_platform/extensions/futures/integration/test_futures_python.py +++ b/openbb_platform/extensions/futures/integration/test_futures_python.py @@ -52,6 +52,8 @@ def test_futures_load(params, obb): "params", [ ({"symbol": "AAPL", "date": "2023-01-01"}), + ({"provider": "cboe", "symbol": "AAPL", "date": "2023-01-01"}), + ({"provider": "yfinance", "symbol": "AAPL", "date": "2023-01-01"}), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/news/integration/test_news_api.py b/openbb_platform/extensions/news/integration/test_news_api.py index 6e6cecbbf11..63fa4662819 100644 --- a/openbb_platform/extensions/news/integration/test_news_api.py +++ b/openbb_platform/extensions/news/integration/test_news_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -41,6 +41,18 @@ def headers(): "limit": 20, } ), + ( + { + "provider": "fmp", + "limit": 20, + } + ), + ( + { + "provider": "intrinio", + "limit": 20, + } + ), ], ) @pytest.mark.integration @@ -49,6 +61,6 @@ def test_news_globalnews(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/news/globalnews?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/news/integration/test_news_python.py b/openbb_platform/extensions/news/integration/test_news_python.py index c94fc54a68f..6c7d15232a1 100644 --- a/openbb_platform/extensions/news/integration/test_news_python.py +++ b/openbb_platform/extensions/news/integration/test_news_python.py @@ -38,6 +38,18 @@ def obb(pytestconfig): "limit": 20, } ), + ( + { + "provider": "fmp", + "limit": 20, + } + ), + ( + { + "provider": "intrinio", + "limit": 20, + } + ), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index ae470fddae5..c82441a2bbc 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -10,7 +10,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -31,7 +31,7 @@ def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=5) + result = requests.get(url, headers=auth_header(), timeout=10) return result.json()["results"] @@ -75,7 +75,7 @@ def test_qa_normality(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/normality?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -94,7 +94,7 @@ def test_qa_capm(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/capm?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -127,7 +127,7 @@ def test_qa_om(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/om?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -146,7 +146,7 @@ def test_qa_kurtosis(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/kurtosis?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -179,7 +179,7 @@ def test_qa_unitroot(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/unitroot?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -198,7 +198,7 @@ def test_qa_sh(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/sh?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -233,7 +233,7 @@ def test_qa_so(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/so?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -284,7 +284,7 @@ def test_qa_quantile(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/quantile?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -303,6 +303,6 @@ def test_qa_summary(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/summary?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/stocks/integration/test_stocks_api.py b/openbb_platform/extensions/stocks/integration/test_stocks_api.py index e497887e5cc..705c932df12 100644 --- a/openbb_platform/extensions/stocks/integration/test_stocks_api.py +++ b/openbb_platform/extensions/stocks/integration/test_stocks_api.py @@ -7,7 +7,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -33,9 +33,9 @@ def headers(): ), ( { - "company_name": "Apple Inc", - "company_name_search": "AAPL", - "sic": "35719904", + "company_name": "Apple Inc.", + "company_name_search": "Apple Inc.", + "sic": "3571", "include_sources": True, "order": "asc", "sort": "filing_date", @@ -43,6 +43,33 @@ def headers(): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2022-10-27", + "filing_date_lt": "2022-11-01", + "filing_date_lte": "2022-11-01", + "filing_date_gt": "2022-10-10", + "filing_date_gte": "2022-10-10", + "period_of_report_date": "2022-09-24", + "period_of_report_date_lt": "2022-11-01", + "period_of_report_date_lte": "2022-11-01", + "period_of_report_date_gt": "2022-10-10", + "period_of_report_date_gte": "2022-10-10", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "fmp", + "cik": "0000320193", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "yfinance", } ), ], @@ -53,7 +80,7 @@ def test_stocks_fa_balance(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/balance?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -68,7 +95,7 @@ def test_stocks_fa_balance_growth(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/balance_growth?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -83,7 +110,7 @@ def test_stocks_fa_cal(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/cal?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -114,6 +141,33 @@ def test_stocks_fa_cal(params, headers): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2023-09-15", + "filing_date_lt": "2023-09-20", + "filing_date_lte": "2023-09-20", + "filing_date_gt": "2023-09-10", + "filing_date_gte": "2023-09-10", + "period_of_report_date": "2023-10-15", + "period_of_report_date_lt": "2023-10-20", + "period_of_report_date_lte": "2023-10-20", + "period_of_report_date_gt": "2023-10-10", + "period_of_report_date_gte": "2023-10-10", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "fmp", + "cik": "0000320193", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "yfinance", } ), ], @@ -124,7 +178,7 @@ def test_stocks_fa_cash(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/cash?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -139,7 +193,7 @@ def test_stocks_fa_cash_growth(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/cash_growth?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -154,7 +208,7 @@ def test_stocks_fa_comp(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/comp?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -169,7 +223,7 @@ def test_stocks_fa_comsplit(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/comsplit?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -184,7 +238,7 @@ def test_stocks_fa_divs(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/divs?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -199,7 +253,7 @@ def test_stocks_fa_earning(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/earning?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -214,7 +268,7 @@ def test_stocks_fa_emp(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/emp?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -229,7 +283,7 @@ def test_stocks_fa_est(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/est?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -250,9 +304,9 @@ def test_stocks_fa_est(params, headers): ), ( { - "company_name": "Apple Inc", - "company_name_search": "AAPL", - "sic": "35719904", + "company_name": "Apple Inc.", + "company_name_search": "Apple Inc.", + "sic": "3571", "include_sources": True, "order": "asc", "sort": "filing_date", @@ -260,6 +314,33 @@ def test_stocks_fa_est(params, headers): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2022-10-27", + "filing_date_lt": "2022-11-01", + "filing_date_lte": "2022-11-01", + "filing_date_gt": "2022-10-10", + "filing_date_gte": "2022-10-10", + "period_of_report_date": "2022-09-24", + "period_of_report_date_lt": "2022-11-01", + "period_of_report_date_lte": "2022-11-01", + "period_of_report_date_gt": "2022-10-10", + "period_of_report_date_gte": "2022-10-10", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "fmp", + "cik": "0000320193", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "yfinance", } ), ], @@ -270,7 +351,7 @@ def test_stocks_fa_income(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/income?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -285,7 +366,7 @@ def test_stocks_fa_income_growth(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/income_growth?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -310,7 +391,7 @@ def test_stocks_fa_ins(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/ins?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -325,7 +406,7 @@ def test_stocks_fa_ins_own(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/ins_own?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -340,7 +421,7 @@ def test_stocks_fa_metrics(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/metrics?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -355,7 +436,7 @@ def test_stocks_fa_mgmt(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/mgmt?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -370,7 +451,7 @@ def test_stocks_fa_overview(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/overview?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -385,7 +466,7 @@ def test_stocks_fa_own(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/own?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -400,7 +481,7 @@ def test_stocks_fa_pt(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/pt?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -415,7 +496,7 @@ def test_stocks_fa_pta(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/pta?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -430,7 +511,7 @@ def test_stocks_fa_ratios(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/ratios?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -445,7 +526,7 @@ def test_stocks_fa_revgeo(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/revgeo?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -460,7 +541,7 @@ def test_stocks_fa_revseg(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/revseg?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -475,7 +556,7 @@ def test_stocks_fa_filings(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/filings?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -490,7 +571,7 @@ def test_stocks_fa_shrs(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/shrs?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -505,7 +586,7 @@ def test_stocks_fa_split(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/split?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -520,7 +601,7 @@ def test_stocks_fa_transcript(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/fa/transcript?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -535,7 +616,7 @@ def test_stocks_ca_peers(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/ca/peers?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -545,6 +626,7 @@ def test_stocks_ca_peers(params, headers): [ ({"symbol": "AAPL"}), ({"date": "2023-01-01", "provider": "intrinio", "symbol": "AAPL"}), + ({"provider": "cboe", "symbol": "AAPL"}), ], ) @pytest.mark.integration @@ -553,7 +635,7 @@ def test_stocks_options_chains(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/options/chains?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -574,6 +656,7 @@ def test_stocks_options_chains(params, headers): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-06-06", + "function_": "TIME_SERIES_DAILY", } ), ( @@ -601,6 +684,7 @@ def test_stocks_options_chains(params, headers): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "timeseries": 1, } ), ( @@ -610,16 +694,20 @@ def test_stocks_options_chains(params, headers): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( { "timezone": "UTC", + "source": "realtime", "interval_size": "30m", "provider": "intrinio", "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "start_time": "00:00:00", + "end_time": "23:59:59", } ), ( @@ -631,6 +719,8 @@ def test_stocks_options_chains(params, headers): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "start_time": "00:00:00", + "end_time": "23:59:59", } ), ( @@ -707,7 +797,7 @@ def test_stocks_load(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/load?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -746,6 +836,27 @@ def test_stocks_load(params, headers): "limit": 20, } ), + ( + { + "provider": "fmp", + "symbols": "AAPL", + "limit": 20, + } + ), + ( + { + "provider": "yfinance", + "symbols": "AAPL", + "limit": 20, + } + ), + ( + { + "provider": "intrinio", + "symbols": "AAPL", + "limit": 20, + } + ), ], ) @pytest.mark.integration @@ -754,7 +865,7 @@ def test_stocks_news(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/news?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -769,7 +880,7 @@ def test_stocks_multiples(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/multiples?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -784,7 +895,7 @@ def test_stocks_search(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/search?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -794,6 +905,7 @@ def test_stocks_search(params, headers): [ ({"symbol": "AAPL"}), ({"source": "iex", "provider": "intrinio", "symbol": "AAPL"}), + ({"symbol": "AAPL", "provider": "fmp"}), ], ) @pytest.mark.integration @@ -802,7 +914,7 @@ def test_stocks_quote(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/quote?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -817,6 +929,6 @@ def test_stocks_info(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/stocks/info?{query_str}" - result = requests.get(url, headers=headers, timeout=5) + result = requests.get(url, headers=headers, timeout=10) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/stocks/integration/test_stocks_python.py b/openbb_platform/extensions/stocks/integration/test_stocks_python.py index 83157bdfac7..31008e4ed9b 100644 --- a/openbb_platform/extensions/stocks/integration/test_stocks_python.py +++ b/openbb_platform/extensions/stocks/integration/test_stocks_python.py @@ -29,9 +29,9 @@ def obb(pytestconfig): ), ( { - "company_name": "Apple Inc", - "company_name_search": "AAPL", - "sic": "35719904", + "company_name": "Apple Inc.", + "company_name_search": "Apple Inc.", + "sic": "3571", "include_sources": True, "order": "asc", "sort": "filing_date", @@ -39,6 +39,33 @@ def obb(pytestconfig): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2022-10-27", + "filing_date_lt": "2022-11-01", + "filing_date_lte": "2022-11-01", + "filing_date_gt": "2022-10-10", + "filing_date_gte": "2022-10-10", + "period_of_report_date": "2022-09-24", + "period_of_report_date_lt": "2022-11-01", + "period_of_report_date_lte": "2022-11-01", + "period_of_report_date_gt": "2022-10-10", + "period_of_report_date_gte": "2022-10-10", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "fmp", + "cik": "0000320193", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "yfinance", } ), ], @@ -100,9 +127,9 @@ def test_stocks_fa_cal(params, obb): ), ( { - "company_name": "Apple Inc", - "company_name_search": "AAPL", - "sic": "35719904", + "company_name": "Apple Inc.", + "company_name_search": "Apple Inc.", + "sic": "3571", "include_sources": True, "order": "asc", "sort": "filing_date", @@ -110,6 +137,33 @@ def test_stocks_fa_cal(params, obb): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2022-10-27", + "filing_date_lt": "2022-11-01", + "filing_date_lte": "2022-11-01", + "filing_date_gt": "2022-10-10", + "filing_date_gte": "2022-10-10", + "period_of_report_date": "2022-09-24", + "period_of_report_date_lt": "2022-11-01", + "period_of_report_date_lte": "2022-11-01", + "period_of_report_date_gt": "2022-10-10", + "period_of_report_date_gte": "2022-10-10", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "fmp", + "cik": "0000320193", + } + ), + ( + { + "symbol": "AAPL", + "period": "annual", + "limit": 12, + "provider": "yfinance", } ), ], @@ -241,9 +295,9 @@ def test_stocks_fa_est(params, obb): ), ( { - "company_name": "Apple Inc", - "company_name_search": "AAPL", - "sic": "35719904", + "company_name": "Apple Inc.", + "company_name_search": "Apple Inc.", + "sic": "3571", "include_sources": True, "order": "asc", "sort": "filing_date", @@ -251,6 +305,33 @@ def test_stocks_fa_est(params, obb): "symbol": "AAPL", "period": "annual", "limit": 12, + "filing_date": "2022-10-27", + "filing_date_lt": "2022-11-01", + "filing_date_lte": "2022-11-01", + "filing_date_gt": "2022-10-10", + "filing_date_gte": "2022-10-10", + "period_of_report_date": "2022-09-24", + "period_of_report_date_lt": "2022-11-01", + "period_of_report_date_lte": "2022-11-01", + "period_of_report_date_gt": "2022-10-10", + "period_of_report_date_gte": "2022-10-10", + } + ), + ( + { + "provider": "fmp", + "symbol": "AAPL", + "limit": 12, + "period": "annual", + "cik": "0000320193", + } + ), + ( + { + "provider": "yfinance", + "symbol": "AAPL", + "limit": 12, + "period": "annual", } ), ], @@ -265,9 +346,7 @@ def test_stocks_fa_income(params, obb): @pytest.mark.parametrize( "params", - [ - ({"symbol": "AAPL", "limit": 10, "period": "annual"}), - ], + [({"symbol": "AAPL", "limit": 10, "period": "annual"})], ) @pytest.mark.integration def test_stocks_fa_income_growth(params, obb): @@ -521,6 +600,7 @@ def test_stocks_ca_peers(params, obb): [ ({"symbol": "AAPL"}), ({"date": "2023-01-01", "provider": "intrinio", "symbol": "AAPL"}), + ({"provider": "cboe", "symbol": "AAPL"}), ], ) @pytest.mark.integration @@ -553,6 +633,7 @@ def test_stocks_options_chains(params, obb): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-06-06", + "function_": "TIME_SERIES_DAILY", } ), ( @@ -580,6 +661,7 @@ def test_stocks_options_chains(params, obb): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "timeseries": 1, } ), ( @@ -589,16 +671,20 @@ def test_stocks_options_chains(params, obb): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-06-06", + "timeseries": 1, } ), ( { "timezone": "UTC", + "source": "realtime", "interval_size": "30m", "provider": "intrinio", "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "start_time": "00:00:00", + "end_time": "23:59:59", } ), ( @@ -610,6 +696,8 @@ def test_stocks_options_chains(params, obb): "symbol": "AAPL", "start_date": "2023-01-01", "end_date": "2023-01-02", + "start_time": "00:00:00", + "end_time": "23:59:59", } ), ( @@ -722,6 +810,27 @@ def test_stocks_load(params, obb): "limit": 20, } ), + ( + { + "provider": "fmp", + "symbols": "AAPL", + "limit": 20, + } + ), + ( + { + "provider": "yfinance", + "symbols": "AAPL", + "limit": 20, + } + ), + ( + { + "provider": "intrinio", + "symbols": "AAPL", + "limit": 20, + } + ), ], ) @pytest.mark.integration @@ -764,6 +873,7 @@ def test_stocks_search(params, obb): [ ({"symbol": "AAPL"}), ({"source": "iex", "provider": "intrinio", "symbol": "AAPL"}), + ({"symbol": "AAPL", "provider": "fmp"}), ], ) @pytest.mark.integration diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 25bcb1b90fd..6d4086405df 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -10,7 +10,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -31,7 +31,7 @@ def get_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=5) + result = requests.get(url, headers=auth_header(), timeout=10) return result.json()["results"] @@ -93,7 +93,7 @@ def test_ta_atr(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/atr?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -130,7 +130,7 @@ def test_ta_fib(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/fib?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -149,7 +149,7 @@ def test_ta_obv(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/obv?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -168,7 +168,7 @@ def test_ta_fisher(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/fisher?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -203,7 +203,7 @@ def test_ta_adosc(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/adosc?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -242,7 +242,7 @@ def test_ta_bbands(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/bbands?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -277,7 +277,7 @@ def test_ta_zlma(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/zlma?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -303,7 +303,7 @@ def test_ta_aroon(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/aroon?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -338,7 +338,7 @@ def test_ta_sma(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/sma?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -375,7 +375,7 @@ def test_ta_demark(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/demark?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -394,7 +394,7 @@ def test_ta_vwap(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/vwap?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -431,7 +431,7 @@ def test_ta_macd(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/macd?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -466,7 +466,7 @@ def test_ta_hma(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/hma?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -501,7 +501,7 @@ def test_ta_donchian(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/donchian?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -540,7 +540,7 @@ def test_ta_ichimoku(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ichimoku?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -566,7 +566,7 @@ def test_ta_clenow(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/clenow?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -585,7 +585,7 @@ def test_ta_ad(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ad?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -620,7 +620,7 @@ def test_ta_adx(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/adx?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -655,7 +655,7 @@ def test_ta_wma(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/wma?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -681,7 +681,7 @@ def test_ta_cci(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cci?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -718,7 +718,7 @@ def test_ta_rsi(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/rsi?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -753,7 +753,7 @@ def test_ta_stoch(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/stoch?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -790,7 +790,7 @@ def test_ta_kc(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/kc?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -809,7 +809,7 @@ def test_ta_cg(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cg?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -846,7 +846,7 @@ def test_ta_cones(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cones?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @@ -881,6 +881,6 @@ def test_ta_ema(params, headers): query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ema?{query_str}" - result = requests.post(url, headers=headers, timeout=5, data=data) + result = requests.post(url, headers=headers, timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index d64cf2ab7de..f838da743a2 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -31,7 +31,7 @@ def get_token(): return requests.post( "http://0.0.0.0:8000/api/v1/account/token", data={"username": "openbb", "password": "openbb"}, - timeout=5, + timeout=10, ) @@ -51,8 +51,8 @@ def write_test_w_template( params_str = ",\n".join([f"({params})" for params in params_list]) http_template_request = { - "get": "requests.get(url, headers=headers, timeout=5)", - "post": "requests.post(url, headers=headers, timeout=5, data=data)", + "get": "requests.get(url, headers=headers, timeout=10)", + "post": "requests.post(url, headers=headers, timeout=10, data=data)", } http_template_params = {"get": "", "post": "data = json.dumps(params.pop('data'))"} From c6da482fbdeeda0ab4e78ac71afa25b4d8715496 Mon Sep 17 00:00:00 2001 From: Diogo Sousa Date: Fri, 6 Oct 2023 11:06:49 +0100 Subject: [PATCH 18/45] add http basic header to integration tests --- .../platform-api-integration-test.yml | 3 ++ .../crypto/integration/test_crypto_api.py | 12 ++----- .../integration/test_econometrics_api.py | 31 ++++++------------- .../economy/integration/test_economy_api.py | 13 ++------ .../integration/test_fixedincome_api.py | 12 ++----- .../forex/integration/test_forex_api.py | 12 ++----- .../futures/integration/test_futures_api.py | 12 ++----- .../news/integration/test_news_api.py | 12 ++----- .../extensions/qa/integration/test_qa_api.py | 31 ++++++------------- .../stocks/integration/test_stocks_api.py | 12 ++----- .../extensions/ta/integration/test_ta_api.py | 31 ++++++------------- .../extensions/tests/utils/helpers.py | 13 ++++++++ .../utils/integration_tests_api_generator.py | 13 ++------ openbb_platform/tests/conftest.py | 4 ++- 14 files changed, 66 insertions(+), 145 deletions(-) create mode 100644 openbb_platform/extensions/tests/utils/helpers.py diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index 2822c967f22..2a13e447a72 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -15,6 +15,9 @@ jobs: runs-on: ubuntu-latest env: SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }} + OPENBB_API_AUTH: true + OPENBB_API_USERNAME: 'USER' + OPENBB_API_PASSWORD: 'PASS' steps: - name: Slack Notification - Starting diff --git a/openbb_platform/extensions/crypto/integration/test_crypto_api.py b/openbb_platform/extensions/crypto/integration/test_crypto_api.py index 8bec440e201..4e6d773702e 100644 --- a/openbb_platform/extensions/crypto/integration/test_crypto_api.py +++ b/openbb_platform/extensions/crypto/integration/test_crypto_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 482e070fb65..55558ed639a 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -1,37 +1,22 @@ import json import random +from extensions.tests.utils.helpers import get_auth import pytest import requests from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - -def auth_header(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} - - @pytest.fixture(scope="session") def headers(): - h = {} - auth = auth_header() - h.update(auth) - return h + return {"Authorization": get_auth()} -def get_data(menu: str, symbol: str, provider: str): +def get_data(menu: str, symbol: str, provider: str, headers): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=10) + result = requests.get(url, headers=headers, timeout=10) return result.json()["results"] @@ -45,7 +30,9 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + data["stocks_data"] = get_data( + "stocks", symbol=symbol, provider=provider, headers=headers + ) return data["stocks_data"] @@ -57,7 +44,9 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + data["crypto_data"] = get_data( + menu="crypto", symbol=symbol, provider=provider, headers=headers + ) return data["crypto_data"] diff --git a/openbb_platform/extensions/economy/integration/test_economy_api.py b/openbb_platform/extensions/economy/integration/test_economy_api.py index d7e98bf85ce..20353c98390 100644 --- a/openbb_platform/extensions/economy/integration/test_economy_api.py +++ b/openbb_platform/extensions/economy/integration/test_economy_api.py @@ -1,20 +1,13 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py index cb750ba3fa3..4cd9a44484b 100644 --- a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py +++ b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/forex/integration/test_forex_api.py b/openbb_platform/extensions/forex/integration/test_forex_api.py index c1438b736a6..c7327baff89 100644 --- a/openbb_platform/extensions/forex/integration/test_forex_api.py +++ b/openbb_platform/extensions/forex/integration/test_forex_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/futures/integration/test_futures_api.py b/openbb_platform/extensions/futures/integration/test_futures_api.py index 99fdff6096b..56427dd9ba3 100644 --- a/openbb_platform/extensions/futures/integration/test_futures_api.py +++ b/openbb_platform/extensions/futures/integration/test_futures_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/news/integration/test_news_api.py b/openbb_platform/extensions/news/integration/test_news_api.py index 63fa4662819..ecd8c5a6a66 100644 --- a/openbb_platform/extensions/news/integration/test_news_api.py +++ b/openbb_platform/extensions/news/integration/test_news_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index c82441a2bbc..cd5a90714f7 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -3,35 +3,20 @@ import random import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - -def auth_header(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} - - @pytest.fixture(scope="session") def headers(): - h = {} - auth = auth_header() - h.update(auth) - return h + return {"Authorization": get_auth()} -def get_data(menu: str, symbol: str, provider: str): +def get_data(menu: str, symbol: str, provider: str, headers): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=10) + result = requests.get(url, headers=headers, timeout=10) return result.json()["results"] @@ -45,7 +30,9 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + data["stocks_data"] = get_data( + "stocks", symbol=symbol, provider=provider, headers=headers + ) return data["stocks_data"] @@ -57,7 +44,9 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + data["crypto_data"] = get_data( + menu="crypto", symbol=symbol, provider=provider, headers=headers + ) return data["crypto_data"] diff --git a/openbb_platform/extensions/stocks/integration/test_stocks_api.py b/openbb_platform/extensions/stocks/integration/test_stocks_api.py index 705c932df12..6a60224d20b 100644 --- a/openbb_platform/extensions/stocks/integration/test_stocks_api.py +++ b/openbb_platform/extensions/stocks/integration/test_stocks_api.py @@ -1,20 +1,12 @@ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 6d4086405df..cf82a5e0b8a 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -3,35 +3,20 @@ import random import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - -def auth_header(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} - - @pytest.fixture(scope="session") def headers(): - h = {} - auth = auth_header() - h.update(auth) - return h + return {"Authorization": get_auth()} -def get_data(menu: str, symbol: str, provider: str): +def get_data(menu: str, symbol: str, provider: str, headers): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=auth_header(), timeout=10) + result = requests.get(url, headers=headers, timeout=10) return result.json()["results"] @@ -45,7 +30,9 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data("stocks", symbol=symbol, provider=provider) + data["stocks_data"] = get_data( + "stocks", symbol=symbol, provider=provider, headers=headers + ) return data["stocks_data"] @@ -57,7 +44,9 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data(menu="crypto", symbol=symbol, provider=provider) + data["crypto_data"] = get_data( + menu="crypto", symbol=symbol, provider=provider, headers=headers + ) return data["crypto_data"] diff --git a/openbb_platform/extensions/tests/utils/helpers.py b/openbb_platform/extensions/tests/utils/helpers.py new file mode 100644 index 00000000000..b4c307b542a --- /dev/null +++ b/openbb_platform/extensions/tests/utils/helpers.py @@ -0,0 +1,13 @@ +import base64 + +from openbb_core.env import Env + + +def get_auth() -> str: + """Returns the basic auth header.""" + + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return f"Basic {base64_bytes.decode('ascii')}" diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index f838da743a2..5923fa84dbe 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -24,21 +24,12 @@ def write_init_test_template(http_method: str, path: str): template += """ import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring - -def get_token(): - return requests.post( - "http://0.0.0.0:8000/api/v1/account/token", - data={"username": "openbb", "password": "openbb"}, - timeout=10, - ) - - @pytest.fixture(scope="session") def headers(): - access_token = get_token().json()["access_token"] - return {"Authorization": f"Bearer {access_token}"} + return {"Authorization": get_auth()} """ with open(path, "w") as f: diff --git a/openbb_platform/tests/conftest.py b/openbb_platform/tests/conftest.py index 2c3d415748d..7d19c5f6572 100644 --- a/openbb_platform/tests/conftest.py +++ b/openbb_platform/tests/conftest.py @@ -1,2 +1,4 @@ # TODO: See if we can dynamically import the test modules under the openbb_platform -# file structure. +# f + +# TODO: Add global fixture for headers here From b10fa4739744c140c9ea09c526d87d77edafcf28 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Fri, 6 Oct 2023 11:40:47 +0100 Subject: [PATCH 19/45] typo --- .../extensions/economy/integration/test_economy_api.py | 1 - 1 file changed, 1 deletion(-) diff --git a/openbb_platform/extensions/economy/integration/test_economy_api.py b/openbb_platform/extensions/economy/integration/test_economy_api.py index 20353c98390..6dba28d1f96 100644 --- a/openbb_platform/extensions/economy/integration/test_economy_api.py +++ b/openbb_platform/extensions/economy/integration/test_economy_api.py @@ -7,7 +7,6 @@ from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): return {"Authorization": get_auth()} - return {"Authorization": get_auth()} @pytest.mark.parametrize( From cfd1ca4ab4243fc345a10a0e90558c17dd15e6e8 Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 10:21:34 -0400 Subject: [PATCH 20/45] Update platform-api-integration-test.yml --- .github/workflows/platform-api-integration-test.yml | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index 2a13e447a72..ce03e6afc1a 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -1,6 +1,9 @@ name: API Integration Tests on: + pull_request: + branches: + - feature/openbb-sdk-v4 push: branches: - feature/openbb-sdk-v4 @@ -10,6 +13,7 @@ concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true + jobs: api-integration-tests: runs-on: ubuntu-latest @@ -60,6 +64,7 @@ jobs: ./openbb_platform/providers/quandl \ ./openbb_platform/providers/fmp \ ./openbb_platform/providers/yfinance \ + ./openbb_platform/providers/intrinio \ ./openbb_platform/extensions/futures \ ./openbb_platform/extensions/qa \ ./openbb_platform/extensions/ta @@ -87,7 +92,8 @@ jobs: "fmp_api_key": "${{ secrets.FMP_API_KEY }}", "polygon_api_key": "${{ secrets.POLYGON_API_KEY }}", "alpha_vantage_api_key": "${{ secrets.ALPHA_VANTAGE_API_KEY }}", - "fred_api_key": "${{ secrets.FRED_API_KEY }}" + "fred_api_key": "${{ secrets.FRED_API_KEY }}", + "intrinio_api_key": "${{ secrets.INTRINIO_API_KEY }}" } }' > ${{ github.workspace }}/.openbb_platform/user_settings.json @@ -125,3 +131,4 @@ jobs: steps: ${{ toJson(steps) }} channel: "#workflows" if: always() + From c345ca7de0ae4c4900543976158caa40bcbc164f Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 10:29:46 -0400 Subject: [PATCH 21/45] change location --- .github/workflows/platform-api-integration-test.yml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index ce03e6afc1a..07e1a1b4e03 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -13,7 +13,6 @@ concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true - jobs: api-integration-tests: runs-on: ubuntu-latest @@ -79,13 +78,13 @@ jobs: - name: Populate System Setting Files run: | - mkdir -p ${{ github.workspace }}/.openbb_platform - touch ${{ github.workspace }}/.openbb_platform/system_settings.json - echo '{"log_collect":false}' > ${{ github.workspace }}/.openbb_platform/system_settings.json + mkdir -p /.openbb_platform + touch /.openbb_platform/system_settings.json + echo '{"log_collect":false}' > /.openbb_platform/system_settings.json - name: Create and Populate user_settings.json from GitHub Secrets run: | - touch ${{ github.workspace }}/.openbb_platform/user_settings.json + touch /.openbb_platform/user_settings.json echo '{ "credentials": { "benzinga_api_key": ${{ secrets.BENZINGA_API_KEY }}, @@ -95,7 +94,7 @@ jobs: "fred_api_key": "${{ secrets.FRED_API_KEY }}", "intrinio_api_key": "${{ secrets.INTRINIO_API_KEY }}" } - }' > ${{ github.workspace }}/.openbb_platform/user_settings.json + }' > /.openbb_platform/user_settings.json - name: Launch the Uvicorn Process run: | @@ -131,4 +130,3 @@ jobs: steps: ${{ toJson(steps) }} channel: "#workflows" if: always() - From f347933e92f5d1e844c1e5f51ef368929de160b5 Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 10:37:20 -0400 Subject: [PATCH 22/45] check something --- .github/workflows/platform-api-integration-test.yml | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index 07e1a1b4e03..29e014c56b0 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -78,13 +78,14 @@ jobs: - name: Populate System Setting Files run: | - mkdir -p /.openbb_platform - touch /.openbb_platform/system_settings.json - echo '{"log_collect":false}' > /.openbb_platform/system_settings.json + mkdir -p ~/.openbb_platform + touch ~/.openbb_platform/system_settings.json + echo '{"log_collect":false}' > ~/.openbb_platform/system_settings.json + cat ~/.openbb_platform/system_settings.json - name: Create and Populate user_settings.json from GitHub Secrets run: | - touch /.openbb_platform/user_settings.json + touch ~/.openbb_platform/user_settings.json echo '{ "credentials": { "benzinga_api_key": ${{ secrets.BENZINGA_API_KEY }}, @@ -94,13 +95,12 @@ jobs: "fred_api_key": "${{ secrets.FRED_API_KEY }}", "intrinio_api_key": "${{ secrets.INTRINIO_API_KEY }}" } - }' > /.openbb_platform/user_settings.json + }' > ~/.openbb_platform/user_settings.json - name: Launch the Uvicorn Process run: | source runner_env/bin/activate pip list - pwd uvicorn openbb_core.api.rest_api:app --host 0.0.0.0 --port 8000 --reload & - name: Wait for 1 minute @@ -110,7 +110,6 @@ jobs: run: | source runner_env/bin/activate pip list - pwd cd openbb_platform pytest . -m integration From 6d124d38339c42394edf68742a7b37d65943a61f Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 10:50:26 -0400 Subject: [PATCH 23/45] add cache --- .../workflows/platform-api-integration-test.yml | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index 29e014c56b0..9490b6e4978 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -49,7 +49,7 @@ jobs: uses: actions/cache@v3 with: path: runner_env - key: venv-${{ runner.os }}-v1-${{ hashFiles('**/poetry.lock', '**/dev_install.py') }} + key: runner_env-${{ runner.os }}-v1-${{ hashFiles('**/poetry.lock', '**/dev_install.py') }} - name: Install Dependencies if: steps.cached-python-environment.outputs.cache-hit != 'true' @@ -103,8 +103,8 @@ jobs: pip list uvicorn openbb_core.api.rest_api:app --host 0.0.0.0 --port 8000 --reload & - - name: Wait for 1 minute - run: sleep 60 + - name: Wait for 10 seconds + run: sleep 10 - name: Run API Integration Tests run: | @@ -113,6 +113,14 @@ jobs: cd openbb_platform pytest . -m integration + - name: Cache pip packages + uses: actions/cache@v2 + with: + path: ~/.cache/pip + key: runner_env-${{ runner.os }}-v1-${{ hashFiles('**/poetry.lock', '**/dev_install.py') }} + restore-keys: | + ${{ runner.os }}-pip- + - name: Upload summary to Slack uses: adrey/slack-file-upload-action@master with: From a14d18830ef9f655625d6a1701aa4f6c080f6856 Mon Sep 17 00:00:00 2001 From: Pratyush Shukla Date: Fri, 6 Oct 2023 20:44:15 +0530 Subject: [PATCH 24/45] fixed auth w/@IgorWounds and @montezdesousa --- .../extensions/crypto/integration/test_crypto_api.py | 10 ++++++++-- .../econometrics/integration/test_econometrics_api.py | 9 +++++++-- .../extensions/economy/integration/test_economy_api.py | 10 ++++++++-- .../fixedincome/integration/test_fixedincome_api.py | 10 ++++++++-- .../extensions/forex/integration/test_forex_api.py | 10 ++++++++-- .../extensions/futures/integration/test_futures_api.py | 10 ++++++++-- .../extensions/news/integration/test_news_api.py | 10 ++++++++-- .../extensions/qa/integration/test_qa_api.py | 9 +++++++-- .../extensions/stocks/integration/test_stocks_api.py | 10 ++++++++-- .../extensions/ta/integration/test_ta_api.py | 9 +++++++-- .../tests/utils/integration_tests_api_generator.py | 10 ++++++++-- 11 files changed, 85 insertions(+), 22 deletions(-) diff --git a/openbb_platform/extensions/crypto/integration/test_crypto_api.py b/openbb_platform/extensions/crypto/integration/test_crypto_api.py index 4e6d773702e..9dc6f14aca2 100644 --- a/openbb_platform/extensions/crypto/integration/test_crypto_api.py +++ b/openbb_platform/extensions/crypto/integration/test_crypto_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 55558ed639a..1343e05eb9c 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -1,15 +1,20 @@ +import base64 import json import random -from extensions.tests.utils.helpers import get_auth import pytest import requests +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} def get_data(menu: str, symbol: str, provider: str, headers): diff --git a/openbb_platform/extensions/economy/integration/test_economy_api.py b/openbb_platform/extensions/economy/integration/test_economy_api.py index 6dba28d1f96..2b0c38fecb0 100644 --- a/openbb_platform/extensions/economy/integration/test_economy_api.py +++ b/openbb_platform/extensions/economy/integration/test_economy_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py index 4cd9a44484b..146555c025d 100644 --- a/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py +++ b/openbb_platform/extensions/fixedincome/integration/test_fixedincome_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/forex/integration/test_forex_api.py b/openbb_platform/extensions/forex/integration/test_forex_api.py index c7327baff89..d54c76f7fb0 100644 --- a/openbb_platform/extensions/forex/integration/test_forex_api.py +++ b/openbb_platform/extensions/forex/integration/test_forex_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/futures/integration/test_futures_api.py b/openbb_platform/extensions/futures/integration/test_futures_api.py index 56427dd9ba3..2ad25d8f258 100644 --- a/openbb_platform/extensions/futures/integration/test_futures_api.py +++ b/openbb_platform/extensions/futures/integration/test_futures_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/news/integration/test_news_api.py b/openbb_platform/extensions/news/integration/test_news_api.py index ecd8c5a6a66..d7bca14967d 100644 --- a/openbb_platform/extensions/news/integration/test_news_api.py +++ b/openbb_platform/extensions/news/integration/test_news_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index cd5a90714f7..69561f2b3f3 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -1,15 +1,20 @@ +import base64 import json import random import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} def get_data(menu: str, symbol: str, provider: str, headers): diff --git a/openbb_platform/extensions/stocks/integration/test_stocks_api.py b/openbb_platform/extensions/stocks/integration/test_stocks_api.py index 6a60224d20b..678b6c2f2df 100644 --- a/openbb_platform/extensions/stocks/integration/test_stocks_api.py +++ b/openbb_platform/extensions/stocks/integration/test_stocks_api.py @@ -1,12 +1,18 @@ +import base64 + import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} @pytest.mark.parametrize( diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index cf82a5e0b8a..426ba565987 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -1,15 +1,20 @@ +import base64 import json import random import pytest import requests -from extensions.tests.utils.helpers import get_auth +from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} def get_data(menu: str, symbol: str, provider: str, headers): diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index 5923fa84dbe..33049367f80 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -24,12 +24,18 @@ def write_init_test_template(http_method: str, path: str): template += """ import pytest import requests -from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring +import base64 +from openbb_core.env import Env + @pytest.fixture(scope="session") def headers(): - return {"Authorization": get_auth()} + userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" + userpass_bytes = userpass.encode("ascii") + base64_bytes = base64.b64encode(userpass_bytes) + + return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} """ with open(path, "w") as f: From 390f9cb29cda88e8de9efc1376000a32f067049b Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Fri, 6 Oct 2023 16:17:17 +0100 Subject: [PATCH 25/45] fixes for econometrics --- .../integration/test_econometrics_api.py | 154 ++++++++------ .../integration/test_econometrics_python.py | 193 +++++++++++++----- .../utils/integration_tests_api_generator.py | 8 +- 3 files changed, 234 insertions(+), 121 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 55558ed639a..1cda241971a 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -1,28 +1,31 @@ import json import random -from extensions.tests.utils.helpers import get_auth +from typing import Literal import pytest import requests +from extensions.tests.utils.helpers import get_auth from openbb_provider.utils.helpers import get_querystring - -@pytest.fixture(scope="session") -def headers(): - return {"Authorization": get_auth()} +data = {} -def get_data(menu: str, symbol: str, provider: str, headers): +def get_headers(): + if "headers" in data: + return data["headers"] + + data["headers"] = {"Authorization": get_auth()} + return data["headers"] + + +def request_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=headers, timeout=10) + result = requests.get(url, headers=get_headers(), timeout=10) return result.json()["results"] -data = {} - - def get_stocks_data(): if "stocks_data" in data: return data["stocks_data"] @@ -30,9 +33,7 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data( - "stocks", symbol=symbol, provider=provider, headers=headers - ) + data["stocks_data"] = request_data("stocks", symbol=symbol, provider=provider) return data["stocks_data"] @@ -44,202 +45,225 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data( - menu="crypto", symbol=symbol, provider=provider, headers=headers + data["crypto_data"] = request_data( + menu="crypto", + symbol=symbol, + provider=provider, ) return data["crypto_data"] +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data()}), - ({"data": get_crypto_data()}), + ({"data": ""}, "stocks"), + ({"data": ""}, "crypto"), ], ) @pytest.mark.integration -def test_econometrics_corr(params, headers): +def test_econometrics_corr(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + + body = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/corr?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": "", "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": "", "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_ols_summary(params, headers): +def test_econometrics_ols_summary(params, data_type): params = {p: v for p, v in params.items() if v} body = json.dumps( { - "data": params.pop("data"), + "data": get_data(data_type), "x_columns": params.pop("x_columns"), } ) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/ols_summary?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=body) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}), - ({"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}), + ( + {"data": "", "y_column": "volume", "x_columns": ["close"]}, + "stocks", + ), + ( + {"data": "", "y_column": "volume", "x_columns": ["close"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_dwat(params, headers): +def test_econometrics_dwat(params, data_type): params = {p: v for p, v in params.items() if v} body = json.dumps( { - "data": params.pop("data"), + "data": get_data(data_type), "x_columns": params.pop("x_columns"), } ) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/dwat?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=body) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "y_column": "volume", "x_columns": ["close"], "lags": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "y_column": "volume", "x_columns": ["close"], "lags": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_bgot(params, headers): +def test_econometrics_bgot(params, data_type): params = {p: v for p, v in params.items() if v} body = json.dumps( { - "data": params.pop("data"), + "data": get_data(data_type), "x_columns": params.pop("x_columns"), } ) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/bgot?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=body) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "columns": ["close", "volume"], - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "columns": ["close", "volume"], - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_coint(params, headers): +def test_econometrics_coint(params, data_type): params = {p: v for p, v in params.items() if v} body = json.dumps( { - "data": params.pop("data"), + "data": get_data(data_type), "columns": params.pop("columns"), } ) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/coint?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=body) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "y_column": "volume", "x_column": "close", "lag": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "y_column": "volume", "x_column": "close", "lag": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_granger(params, headers): +def test_econometrics_granger(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + body = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/granger?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", - [ - ({"data": get_stocks_data(), "column": "close", "regression": "c"}), - ({"data": get_crypto_data(), "column": "volume", "regression": "ctt"}), - ], + "params, data_type", + [({"data": "", "column": "", "regression": ""}, "stocks")], ) @pytest.mark.integration -def test_econometrics_unitroot(params, headers): +def test_econometrics_unitroot(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + body = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/econometrics/unitroot?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=body) assert isinstance(result, requests.Response) assert result.status_code == 200 diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py index ee6d32e0fea..390cb7c6004 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -1,5 +1,6 @@ """Test econometrics extension.""" import random +from typing import Literal import pytest from openbb_core.app.model.obbject import OBBject @@ -49,17 +50,24 @@ def get_crypto_data(): return data["crypto_data"] +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data()}), - ({"data": get_crypto_data()}), + ({"data": ""}, "stocks"), + ({"data": ""}, "crypto"), ], ) @pytest.mark.integration -def test_econometrics_corr(params, obb): +def test_econometrics_corr(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.corr(**params) assert result assert isinstance(result, OBBject) @@ -67,16 +75,24 @@ def test_econometrics_corr(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_ols(params, obb): +def test_econometrics_ols(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.ols(**params) assert result assert isinstance(result, OBBject) @@ -101,23 +117,31 @@ def test_econometrics_ols_summary(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}), - ({"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}), + ( + {"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_dwat(params, obb): +def test_econometrics_dwat(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.dwat(**params) assert result assert isinstance(result, OBBject) @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { @@ -125,7 +149,8 @@ def test_econometrics_dwat(params, obb): "y_column": "volume", "x_columns": ["close"], "lags": "", - } + }, + "stocks", ), ( { @@ -133,40 +158,47 @@ def test_econometrics_dwat(params, obb): "y_column": "volume", "x_columns": ["close"], "lags": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_bgot(params, obb): +def test_econometrics_bgot(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.bgot(**params) assert result assert isinstance(result, OBBject) @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { "data": get_stocks_data(), "columns": ["close", "volume"], - } + }, + "stocks", ), ( { "data": get_crypto_data(), "columns": ["close", "volume"], - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_coint(params, obb): +def test_econometrics_coint(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.coint(**params) assert result assert isinstance(result, OBBject) @@ -174,7 +206,7 @@ def test_econometrics_coint(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { @@ -182,7 +214,8 @@ def test_econometrics_coint(params, obb): "y_column": "volume", "x_column": "close", "lag": "", - } + }, + "stocks", ), ( { @@ -190,14 +223,17 @@ def test_econometrics_coint(params, obb): "y_column": "volume", "x_column": "close", "lag": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_econometrics_granger(params, obb): +def test_econometrics_granger(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.granger(**params) assert result assert isinstance(result, OBBject) @@ -205,32 +241,45 @@ def test_econometrics_granger(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "column": "close", "regression": "c"}), - ({"data": get_crypto_data(), "column": "volume", "regression": "ctt"}), + ({"data": get_stocks_data(), "column": "close", "regression": "c"}, "stocks"), + ( + {"data": get_crypto_data(), "column": "volume", "regression": "ctt"}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_unitroot(params, obb): +def test_econometrics_unitroot(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.unitroot(**params) assert result assert isinstance(result, OBBject) @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelre(params, obb): +def test_econometrics_panelre(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelre(**params) assert result assert isinstance(result, OBBject) @@ -238,16 +287,24 @@ def test_econometrics_panelre(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelbols(params, obb): +def test_econometrics_panelbols(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelbols(**params) assert result assert isinstance(result, OBBject) @@ -255,16 +312,24 @@ def test_econometrics_panelbols(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelpols(params, obb): +def test_econometrics_panelpols(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelpols(**params) assert result assert isinstance(result, OBBject) @@ -272,16 +337,24 @@ def test_econometrics_panelpols(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelols(params, obb): +def test_econometrics_panelols(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelols(**params) assert result assert isinstance(result, OBBject) @@ -289,16 +362,24 @@ def test_econometrics_panelols(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelfd(params, obb): +def test_econometrics_panelfd(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelfd(**params) assert result assert isinstance(result, OBBject) @@ -306,16 +387,24 @@ def test_econometrics_panelfd(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + "stocks", + ), + ( + {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + "crypto", + ), ], ) @pytest.mark.integration -def test_econometrics_panelfmac(params, obb): +def test_econometrics_panelfmac(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) + result = obb.econometrics.panelfmac(**params) assert result assert isinstance(result, OBBject) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index 5923fa84dbe..61d706289a1 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -1,10 +1,10 @@ import os -from platform.core.openbb_core.app.provider_interface import ProviderInterface -from platform.core.openbb_core.app.router import CommandMap from typing import Dict, List, Type, get_type_hints import requests from extensions.tests.utils.integration_tests_generator import get_test_params +from openbb_core.app.provider_interface import ProviderInterface +from openbb_core.app.router import CommandMap def get_http_method(api_paths: Dict[str, dict], route: str): @@ -43,10 +43,10 @@ def write_test_w_template( http_template_request = { "get": "requests.get(url, headers=headers, timeout=10)", - "post": "requests.post(url, headers=headers, timeout=10, data=data)", + "post": "requests.post(url, headers=headers, timeout=10, data=body)", } - http_template_params = {"get": "", "post": "data = json.dumps(params.pop('data'))"} + http_template_params = {"get": "", "post": "body = json.dumps(params.pop('data'))"} template = f""" @pytest.mark.parametrize( From 71e95a53bcd2ce5d3b62761ef0ea6b1d9dd78353 Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 13:24:31 -0400 Subject: [PATCH 26/45] Change extension imports --- openbb_platform/extensions/tests/test_integration_tests_api.py | 2 +- .../extensions/tests/test_integration_tests_python.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index e82ba079339..04310d243b9 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from extensions.tests.utils.integration_tests_testers import ( +from openbb_platform.extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 1303b8ed62b..24cafb99cf9 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from extensions.tests.utils.integration_tests_testers import ( +from openbb_platform.extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, From 39e9136cb8398d93dd792b3eb1419ebf51def17b Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 13:31:16 -0400 Subject: [PATCH 27/45] headers function wasnt being called, just referenced --- .../econometrics/integration/test_econometrics_api.py | 2 +- openbb_platform/extensions/qa/integration/test_qa_api.py | 2 +- openbb_platform/extensions/ta/integration/test_ta_api.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 1343e05eb9c..540ab3971d4 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -36,7 +36,7 @@ def get_stocks_data(): provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 data["stocks_data"] = get_data( - "stocks", symbol=symbol, provider=provider, headers=headers + "stocks", symbol=symbol, provider=provider, headers=headers() ) return data["stocks_data"] diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index 69561f2b3f3..b27cac2e752 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -21,7 +21,7 @@ def get_data(menu: str, symbol: str, provider: str, headers): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=headers, timeout=10) + result = requests.get(url, headers=headers(), timeout=10) return result.json()["results"] diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 426ba565987..53acc89bca1 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -21,7 +21,7 @@ def get_data(menu: str, symbol: str, provider: str, headers): """Randomly pick a symbol and a provider and get data from the selected menu.""" url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=headers, timeout=10) + result = requests.get(url, headers=headers(), timeout=10) return result.json()["results"] From ba169a8e094699dc5df060b7f02e7d9002a6fd21 Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 13:31:52 -0400 Subject: [PATCH 28/45] relative import --- openbb_platform/extensions/tests/test_integration_tests_api.py | 2 +- .../extensions/tests/test_integration_tests_python.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 04310d243b9..516bad4e099 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from openbb_platform.extensions.tests.utils.integration_tests_testers import ( +from .openbb_platform.extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 24cafb99cf9..0098a61a963 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from openbb_platform.extensions.tests.utils.integration_tests_testers import ( +from .openbb_platform.extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, From ce149aaca51c1435e7197cf11fa677c46916c083 Mon Sep 17 00:00:00 2001 From: James Maslek Date: Fri, 6 Oct 2023 13:42:27 -0400 Subject: [PATCH 29/45] econometrics add headers everywhere --- .../integration/test_econometrics_api.py | 58 +++++++++++++------ 1 file changed, 41 insertions(+), 17 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 540ab3971d4..75adada2d9e 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -28,7 +28,7 @@ def get_data(menu: str, symbol: str, provider: str, headers): data = {} -def get_stocks_data(): +def get_stocks_data(headers): if "stocks_data" in data: return data["stocks_data"] @@ -36,12 +36,12 @@ def get_stocks_data(): provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 data["stocks_data"] = get_data( - "stocks", symbol=symbol, provider=provider, headers=headers() + "stocks", symbol=symbol, provider=provider, headers=headers ) return data["stocks_data"] -def get_crypto_data(): +def get_crypto_data(headers): if "crypto_data" in data: return data["crypto_data"] @@ -58,8 +58,8 @@ def get_crypto_data(): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data()}), - ({"data": get_crypto_data()}), + ({"data": get_stocks_data(headers)}), + ({"data": get_crypto_data(headers)}), ], ) @pytest.mark.integration @@ -77,8 +77,20 @@ def test_econometrics_corr(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ( + { + "data": get_stocks_data(headers), + "y_column": "close", + "x_columns": ["date"], + } + ), + ( + { + "data": get_crypto_data(headers), + "y_column": "close", + "x_columns": ["date"], + } + ), ], ) @pytest.mark.integration @@ -102,8 +114,20 @@ def test_econometrics_ols_summary(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}), - ({"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}), + ( + { + "data": get_stocks_data(headers), + "y_column": "volume", + "x_columns": ["close"], + } + ), + ( + { + "data": get_crypto_data(headers), + "y_column": "volume", + "x_columns": ["close"], + } + ), ], ) @pytest.mark.integration @@ -129,7 +153,7 @@ def test_econometrics_dwat(params, headers): [ ( { - "data": get_stocks_data(), + "data": get_stocks_data(headers), "y_column": "volume", "x_columns": ["close"], "lags": "", @@ -137,7 +161,7 @@ def test_econometrics_dwat(params, headers): ), ( { - "data": get_crypto_data(), + "data": get_crypto_data(headers), "y_column": "volume", "x_columns": ["close"], "lags": "2", @@ -168,13 +192,13 @@ def test_econometrics_bgot(params, headers): [ ( { - "data": get_stocks_data(), + "data": get_stocks_data(headers), "columns": ["close", "volume"], } ), ( { - "data": get_crypto_data(), + "data": get_crypto_data(headers), "columns": ["close", "volume"], } ), @@ -203,7 +227,7 @@ def test_econometrics_coint(params, headers): [ ( { - "data": get_stocks_data(), + "data": get_stocks_data(headers), "y_column": "volume", "x_column": "close", "lag": "", @@ -211,7 +235,7 @@ def test_econometrics_coint(params, headers): ), ( { - "data": get_crypto_data(), + "data": get_crypto_data(headers), "y_column": "volume", "x_column": "close", "lag": "2", @@ -234,8 +258,8 @@ def test_econometrics_granger(params, headers): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "column": "close", "regression": "c"}), - ({"data": get_crypto_data(), "column": "volume", "regression": "ctt"}), + ({"data": get_stocks_data(headers), "column": "close", "regression": "c"}), + ({"data": get_crypto_data(headers), "column": "volume", "regression": "ctt"}), ], ) @pytest.mark.integration From d363eacc121b50b30c9be799937d122ef44d44b1 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 22:35:31 +0200 Subject: [PATCH 30/45] Fix QA --- .../integration/test_econometrics_api.py | 1 - .../extensions/qa/integration/test_qa_api.py | 177 ++++++++++-------- 2 files changed, 96 insertions(+), 82 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 9534989ccbf..d2927a8e376 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -25,7 +25,6 @@ def get_headers(): def request_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" result = requests.get(url, headers=get_headers(), timeout=10) return result.json()["results"] diff --git a/openbb_platform/extensions/qa/integration/test_qa_api.py b/openbb_platform/extensions/qa/integration/test_qa_api.py index 69561f2b3f3..eda64698b2b 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_api.py +++ b/openbb_platform/extensions/qa/integration/test_qa_api.py @@ -1,33 +1,40 @@ import base64 import json import random +from typing import Literal import pytest import requests from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring +data = {} + + +def get_headers(): + if "headers" in data: + return data["headers"] -@pytest.fixture(scope="session") -def headers(): userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" userpass_bytes = userpass.encode("ascii") base64_bytes = base64.b64encode(userpass_bytes) - return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} + data["headers"] = {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} + return data["headers"] -def get_data(menu: str, symbol: str, provider: str, headers): +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + +def request_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=headers, timeout=10) + result = requests.get(url, headers=get_headers(), timeout=10) return result.json()["results"] -data = {} - - def get_stocks_data(): if "stocks_data" in data: return data["stocks_data"] @@ -35,9 +42,7 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data( - "stocks", symbol=symbol, provider=provider, headers=headers - ) + data["stocks_data"] = request_data("stocks", symbol=symbol, provider=provider) return data["stocks_data"] @@ -49,254 +54,264 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data( - menu="crypto", symbol=symbol, provider=provider, headers=headers + data["crypto_data"] = request_data( + menu="crypto", + symbol=symbol, + provider=provider, ) return data["crypto_data"] @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_normality(params, headers): +def test_qa_normality(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/normality?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_capm(params, headers): +def test_qa_capm(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/capm?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "threshold_start": "", "threshold_end": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "threshold_start": "0.1", "threshold_end": "1.6", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_om(params, headers): +def test_qa_om(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/om?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "window": "5"}), - ({"data": get_crypto_data(), "target": "high", "window": "10"}), + ({"data": "", "target": "close", "window": "5"}, "stocks"), + ({"data": "", "target": "high", "window": "10"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_kurtosis(params, headers): +def test_qa_kurtosis(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/kurtosis?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "fuller_reg": "c", "kpss_reg": "ct", - } + }, + "stocks", ), ( { - "data": get_stocks_data(), + "data": "", "target": "high", "fuller_reg": "ct", "kpss_reg": "c", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_unitroot(params, headers): +def test_qa_unitroot(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/unitroot?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "rfr": "", "window": ""}), - ({"data": get_crypto_data(), "target": "high", "rfr": "0.5", "window": "250"}), + ({"data": "", "target": "close", "rfr": "", "window": ""}, "stocks"), + ({"data": "", "target": "high", "rfr": "0.5", "window": "250"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_sh(params, headers): +def test_qa_sh(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/sh?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "target_return": "", "window": "", "adjusted": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "close", "target_return": "0.5", "window": "275", "adjusted": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_so(params, headers): +def test_qa_so(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/so?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "window": "220"}), + ({"data": "", "target": "close", "window": "220"}, "stocks"), ], ) @pytest.mark.integration -def test_qa_skew(params, headers): +def test_qa_skew(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/skew?{query_str}" - result = requests.post(url, headers=headers, timeout=60, data=data) + result = requests.post(url, headers=get_headers(), timeout=60, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "window": "10", "quantile_pct": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "window": "50", "quantile_pct": "0.6", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_quantile(params, headers): +def test_qa_quantile(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/quantile?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_summary(params, headers): +def test_qa_summary(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/qa/summary?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 From 494a52e7e119a9043cf8bfd4067c8509936d5891 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 22:49:46 +0200 Subject: [PATCH 31/45] Fix TA --- .../extensions/ta/integration/test_ta_api.py | 464 ++++++++++-------- 1 file changed, 255 insertions(+), 209 deletions(-) diff --git a/openbb_platform/extensions/ta/integration/test_ta_api.py b/openbb_platform/extensions/ta/integration/test_ta_api.py index 426ba565987..68fe9f143af 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_api.py +++ b/openbb_platform/extensions/ta/integration/test_ta_api.py @@ -1,33 +1,40 @@ import base64 import json import random +from typing import Literal import pytest import requests from openbb_core.env import Env from openbb_provider.utils.helpers import get_querystring +data = {} + + +def get_headers(): + if "headers" in data: + return data["headers"] -@pytest.fixture(scope="session") -def headers(): userpass = f"{Env().API_USERNAME}:{Env().API_PASSWORD}" userpass_bytes = userpass.encode("ascii") base64_bytes = base64.b64encode(userpass_bytes) - return {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} + data["headers"] = {"Authorization": f"Basic {base64_bytes.decode('ascii')}"} + return data["headers"] -def get_data(menu: str, symbol: str, provider: str, headers): +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + +def request_data(menu: str, symbol: str, provider: str): """Randomly pick a symbol and a provider and get data from the selected menu.""" - url = f"http://0.0.0.0:8000/api/v1/{menu}/load?symbol={symbol}&provider={provider}" - result = requests.get(url, headers=headers, timeout=10) + result = requests.get(url, headers=get_headers(), timeout=10) return result.json()["results"] -data = {} - - def get_stocks_data(): if "stocks_data" in data: return data["stocks_data"] @@ -35,9 +42,7 @@ def get_stocks_data(): symbol = random.choice(["AAPL", "NVDA", "MSFT", "TSLA", "AMZN", "V"]) # noqa: S311 provider = random.choice(["fmp", "intrinio", "polygon", "yfinance"]) # noqa: S311 - data["stocks_data"] = get_data( - "stocks", symbol=symbol, provider=provider, headers=headers - ) + data["stocks_data"] = request_data("stocks", symbol=symbol, provider=provider) return data["stocks_data"] @@ -49,832 +54,873 @@ def get_crypto_data(): symbol = random.choice(["BTC"]) # noqa: S311 provider = random.choice(["fmp"]) # noqa: S311 - data["crypto_data"] = get_data( - menu="crypto", symbol=symbol, provider=provider, headers=headers + data["crypto_data"] = request_data( + menu="crypto", + symbol=symbol, + provider=provider, ) return data["crypto_data"] @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "mamode": "", "drift": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "15", "mamode": "rma", "drift": "2", "offset": "1", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_atr(params, headers): +def test_ta_atr(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/atr?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "close_column": "", "period": "", "start_date": "", "end_date": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "close_column": "adj_close", "period": "125", "start_date": "", "end_date": "", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_fib(params, headers): +def test_ta_fib(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/fib?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "offset": ""}), - ({"data": get_crypto_data(), "index": "date", "offset": "1"}), + ({"data": "", "index": "", "offset": ""}, "stocks"), + ({"data": "", "index": "date", "offset": "1"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_obv(params, headers): +def test_ta_obv(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/obv?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "signal": ""}), - ({"data": get_crypto_data(), "index": "date", "length": "15", "signal": "2"}), + ({"data": "", "index": "", "length": "", "signal": ""}, "stocks"), + ({"data": "", "index": "date", "length": "15", "signal": "2"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_fisher(params, headers): +def test_ta_fisher(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/fisher?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "fast": "", "slow": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "fast": "5", "slow": "15", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_adosc(params, headers): +def test_ta_adosc(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/adosc?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "std": "", "mamode": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "std": "3", "mamode": "wma", "offset": "1", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_bbands(params, headers): +def test_ta_bbands(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/bbands?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_zlma(params, headers): +def test_ta_zlma(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/zlma?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "30", "scalar": "110", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_aroon(params, headers): +def test_ta_aroon(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/aroon?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_sma(params, headers): +def test_ta_sma(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/sma?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "target": "", "show_all": "", "asint": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "target": "high", "show_all": "true", "asint": "true", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_demark(params, headers): +def test_ta_demark(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/demark?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "anchor": "", "offset": ""}), - ({"data": get_crypto_data(), "index": "date", "anchor": "W", "offset": "5"}), + ({"data": "", "index": "", "anchor": "", "offset": ""}, "stocks"), + ({"data": "", "index": "date", "anchor": "W", "offset": "5"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_vwap(params, headers): +def test_ta_vwap(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/vwap?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "fast": "", "slow": "", "signal": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "fast": "10", "slow": "30", "signal": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_macd(params, headers): +def test_ta_macd(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/macd?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_hma(params, headers): +def test_ta_hma(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/hma?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "lower_length": "", "upper_length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "lower_length": "30", "upper_length": "40", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_donchian(params, headers): +def test_ta_donchian(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/donchian?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "conversion": "", "base": "", "lagging": "", "offset": "", "lookahead": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "conversion": "10", "base": "30", "lagging": "50", "offset": "30", "lookahead": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_ichimoku(params, headers): +def test_ta_ichimoku(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ichimoku?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "target": "", "period": ""}), + ({"data": "", "index": "", "target": "", "period": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "target": "close", "period": "95", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_clenow(params, headers): +def test_ta_clenow(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/clenow?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "offset": ""}), - ({"data": get_crypto_data(), "index": "date", "offset": "5"}), + ({"data": "", "index": "", "offset": ""}, "stocks"), + ({"data": "", "index": "date", "offset": "5"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_ad(params, headers): +def test_ta_ad(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ad?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "scalar": "", "drift": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "60", "scalar": "90.0", "drift": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_adx(params, headers): +def test_ta_adx(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/adx?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "60", "offset": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_wma(params, headers): +def test_ta_wma(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/wma?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "16", "scalar": "0.02", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_cci(params, headers): +def test_ta_cci(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cci?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "scalar": "", "drift": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "16", "scalar": "90.0", "drift": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_rsi(params, headers): +def test_ta_rsi(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/rsi?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "fast_k_period": "", "slow_d_period": "", "slow_k_period": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "fast_k_period": "12", "slow_d_period": "2", "slow_k_period": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_stoch(params, headers): +def test_ta_stoch(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/stoch?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "scalar": "", "mamode": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "22", "scalar": "24", "mamode": "sma", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_kc(params, headers): +def test_ta_kc(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/kc?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": ""}), - ({"data": get_crypto_data(), "index": "date", "length": "20"}), + ({"data": "", "index": "", "length": ""}, "stocks"), + ({"data": "", "index": "date", "length": "20"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_cg(params, headers): +def test_ta_cg(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cg?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "lower_q": "", "upper_q": "", "model": "", "is_crypto": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "lower_q": "0.3", "upper_q": "0.7", "model": "Parkinson", "is_crypto": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_cones(params, headers): +def test_ta_cones(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/cones?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "index": "date", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "", "length": "60", "offset": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_ema(params, headers): +def test_ta_ema(params, data_type): params = {p: v for p, v in params.items() if v} - data = json.dumps(params.pop("data")) + data = json.dumps(get_data(data_type)) query_str = get_querystring(params, []) url = f"http://0.0.0.0:8000/api/v1/ta/ema?{query_str}" - result = requests.post(url, headers=headers, timeout=10, data=data) + result = requests.post(url, headers=get_headers(), timeout=10, data=data) assert isinstance(result, requests.Response) assert result.status_code == 200 From ea4f4a7e2ddb539eff83ceb731950e08581750c1 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:10:46 +0200 Subject: [PATCH 32/45] Fix test --- openbb_platform/extensions/tests/__init__.py | 0 .../tests/test_integration_tests_api.py | 5 +++- .../tests/test_integration_tests_python.py | 2 +- .../extensions/tests/utils/__init__.py | 0 .../tests/utils/integration_tests_testers.py | 26 ++++++++++++------- 5 files changed, 21 insertions(+), 12 deletions(-) create mode 100644 openbb_platform/extensions/tests/__init__.py create mode 100644 openbb_platform/extensions/tests/utils/__init__.py diff --git a/openbb_platform/extensions/tests/__init__.py b/openbb_platform/extensions/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 516bad4e099..a9adaec9c11 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from .openbb_platform.extensions.tests.utils.integration_tests_testers import ( +from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, @@ -28,3 +28,6 @@ def test_api_interface_integration_test_providers() -> None: def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("api", check_missing_integration_test_params) + + +test_api_interface_integration_test_params() diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 0098a61a963..1303b8ed62b 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,6 +1,6 @@ """Test the integration tests.""" import pytest -from .openbb_platform.extensions.tests.utils.integration_tests_testers import ( +from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, diff --git a/openbb_platform/extensions/tests/utils/__init__.py b/openbb_platform/extensions/tests/utils/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 3de971d777a..38b560bc71d 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -2,7 +2,7 @@ import importlib.util import inspect import os -from typing import Any, Callable, Dict, List, Literal, Union, get_type_hints +from typing import Any, Callable, Dict, List, Literal, Tuple, Union, get_type_hints from extensions.tests.utils.integration_tests_generator import ( find_extensions, @@ -49,7 +49,7 @@ def get_module_functions(module_list: List[Any]) -> Dict[str, Any]: def check_missing_providers( - command_params: Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], + command_params: Union[Dict[str, Dict[str, dict]], List[Tuple[Dict[str, str], str]]], function_params: List[dict], function, processing: bool = False, @@ -82,7 +82,7 @@ def check_missing_providers( def check_missing_params( - command_params: Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], + command_params: Union[Dict[str, Dict[str, dict]], List[Tuple[Dict[str, str], str]]], function_params: List[dict], function, processing: bool = False, @@ -110,11 +110,17 @@ def check_missing_params( else: for test_params in function_params: if isinstance(command_params, list): - for expected_param in command_params[0]: - if ( - expected_param not in test_params.keys() - and expected_param != "return" - ): + try: + iter_commands_params = command_params[0][0] + except KeyError: + iter_commands_params = command_params[0] # type: ignore + + for expected_param in iter_commands_params: + try: + used_params = test_params[0].keys() + except KeyError: + used_params = test_params.keys() + if expected_param not in used_params and expected_param != "return": missing_params.append( f"Missing param {expected_param} in function {function}" ) @@ -125,7 +131,7 @@ def check_integration_tests( functions: Dict[str, Any], check_function: Callable[ [ - Union[Dict[str, Dict[str, dict]], List[Dict[str, str]]], + Union[Dict[str, Dict[str, dict]], List[Tuple[Dict[str, str], str]]], List[dict], str, bool, @@ -171,7 +177,7 @@ def check_integration_tests( function_params = functions[function].pytestmark[1].args[1] missing_items = check_function( - processing_command_params, function_params, function, True + processing_command_params, function_params, function, True # type: ignore ) all_missing_items.extend(missing_items) From 8eb149726c590cc2b1e2edc68340691e67e51034 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:28:08 +0200 Subject: [PATCH 33/45] Fix python interface QA and TA --- .../integration/test_econometrics_python.py | 1 - .../qa/integration/test_qa_python.py | 119 +++--- .../ta/integration/test_ta_python.py | 349 +++++++++++------- 3 files changed, 280 insertions(+), 189 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py index 390cb7c6004..70ed77654a3 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -9,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject @pytest.fixture(scope="session") def obb(pytestconfig): """Fixture to setup obb.""" - if pytestconfig.getoption("markexpr") != "not integration": import openbb diff --git a/openbb_platform/extensions/qa/integration/test_qa_python.py b/openbb_platform/extensions/qa/integration/test_qa_python.py index fc36ffd6cfb..756173e03e9 100644 --- a/openbb_platform/extensions/qa/integration/test_qa_python.py +++ b/openbb_platform/extensions/qa/integration/test_qa_python.py @@ -1,5 +1,6 @@ """Test qa extension.""" import random +from typing import Literal import pytest from openbb_core.app.model.obbject import OBBject @@ -8,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject @pytest.fixture(scope="session") def obb(pytestconfig): """Fixture to setup obb.""" - if pytestconfig.getoption("markexpr") != "not integration": import openbb @@ -49,16 +49,22 @@ def get_crypto_data(): return data["crypto_data"] +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_normality(params, obb): +def test_qa_normality(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.normality(**params) assert result @@ -66,15 +72,16 @@ def test_qa_normality(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_capm(params, obb): +def test_qa_capm(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.capm(**params) assert result @@ -82,29 +89,32 @@ def test_qa_capm(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "threshold_start": "", "threshold_end": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "threshold_start": "0.1", "threshold_end": "1.6", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_om(params, obb): +def test_qa_om(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.om(**params) assert result @@ -112,15 +122,16 @@ def test_qa_om(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "window": "5"}), - ({"data": get_crypto_data(), "target": "high", "window": "10"}), + ({"data": "", "target": "close", "window": "5"}, "stocks"), + ({"data": "", "target": "high", "window": "10"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_kurtosis(params, obb): +def test_qa_kurtosis(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.kurtosis(**params) assert result @@ -129,29 +140,32 @@ def test_qa_kurtosis(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "fuller_reg": "c", "kpss_reg": "ct", - } + }, + "stocks", ), ( { - "data": get_stocks_data(), + "data": "", "target": "high", "fuller_reg": "ct", "kpss_reg": "c", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_unitroot(params, obb): +def test_qa_unitroot(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.unitroot(**params) assert result @@ -159,15 +173,16 @@ def test_qa_unitroot(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "rfr": "", "window": ""}), - ({"data": get_crypto_data(), "target": "high", "rfr": "0.5", "window": "250"}), + ({"data": "", "target": "close", "rfr": "", "window": ""}, "stocks"), + ({"data": "", "target": "high", "rfr": "0.5", "window": "250"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_sh(params, obb): +def test_qa_sh(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.sh(**params) assert result @@ -175,31 +190,34 @@ def test_qa_sh(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "target_return": "", "window": "", "adjusted": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "close", "target_return": "0.5", "window": "275", "adjusted": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_so(params, obb): +def test_qa_so(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.so(**params) assert result @@ -207,14 +225,15 @@ def test_qa_so(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close", "window": "220"}), + ({"data": "", "target": "close", "window": "220"}, "stocks"), ], ) @pytest.mark.integration -def test_qa_skew(params, obb): +def test_qa_skew(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.skew(**params) assert result @@ -223,29 +242,32 @@ def test_qa_skew(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "window": "10", "quantile_pct": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "window": "50", "quantile_pct": "0.6", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_qa_quantile(params, obb): +def test_qa_quantile(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.quantile(**params) assert result @@ -254,15 +276,16 @@ def test_qa_quantile(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "target": "close"}), - ({"data": get_crypto_data(), "target": "high"}), + ({"data": "", "target": "close"}, "stocks"), + ({"data": "", "target": "high"}, "crypto"), ], ) @pytest.mark.integration -def test_qa_summary(params, obb): +def test_qa_summary(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.qa.summary(**params) assert result diff --git a/openbb_platform/extensions/ta/integration/test_ta_python.py b/openbb_platform/extensions/ta/integration/test_ta_python.py index 376688ca86e..5d4da9f9a6b 100644 --- a/openbb_platform/extensions/ta/integration/test_ta_python.py +++ b/openbb_platform/extensions/ta/integration/test_ta_python.py @@ -1,5 +1,6 @@ """Test ta extension.""" import random +from typing import Literal import pytest from openbb_core.app.model.obbject import OBBject @@ -8,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject @pytest.fixture(scope="session") def obb(pytestconfig): """Fixture to setup obb.""" - if pytestconfig.getoption("markexpr") != "not integration": import openbb @@ -49,34 +49,42 @@ def get_crypto_data(): return data["crypto_data"] +def get_data(menu: Literal["stocks", "crypto"]): + funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data} + return funcs[menu]() + + @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "mamode": "", "drift": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "15", "mamode": "rma", "drift": "2", "offset": "1", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_atr(params, obb): +def test_ta_atr(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.atr(**params) assert result @@ -85,33 +93,36 @@ def test_ta_atr(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "close_column": "", "period": "", "start_date": "", "end_date": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "close_column": "adj_close", "period": "125", "start_date": "", "end_date": "", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_fib(params, obb): +def test_ta_fib(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.fib(**params) assert result @@ -120,15 +131,16 @@ def test_ta_fib(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "offset": ""}), - ({"data": get_crypto_data(), "index": "date", "offset": "1"}), + ({"data": "", "index": "", "offset": ""}, "stocks"), + ({"data": "", "index": "date", "offset": "1"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_obv(params, obb): +def test_ta_obv(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.obv(**params) assert result @@ -137,15 +149,16 @@ def test_ta_obv(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "signal": ""}), - ({"data": get_crypto_data(), "index": "date", "length": "15", "signal": "2"}), + ({"data": "", "index": "", "length": "", "signal": ""}, "stocks"), + ({"data": "", "index": "date", "length": "15", "signal": "2"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_fisher(params, obb): +def test_ta_fisher(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.fisher(**params) assert result @@ -154,31 +167,34 @@ def test_ta_fisher(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "fast": "", "slow": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "fast": "5", "slow": "15", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_adosc(params, obb): +def test_ta_adosc(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.adosc(**params) assert result @@ -187,35 +203,38 @@ def test_ta_adosc(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "std": "", "mamode": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "std": "3", "mamode": "wma", "offset": "1", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_bbands(params, obb): +def test_ta_bbands(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.bbands(**params) assert result @@ -224,31 +243,34 @@ def test_ta_bbands(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_zlma(params, obb): +def test_ta_zlma(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.zlma(**params) assert result @@ -257,22 +279,24 @@ def test_ta_zlma(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "30", "scalar": "110", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_aroon(params, obb): +def test_ta_aroon(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.aroon(**params) assert result @@ -281,31 +305,34 @@ def test_ta_aroon(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_sma(params, obb): +def test_ta_sma(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.sma(**params) assert result @@ -314,33 +341,36 @@ def test_ta_sma(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "target": "", "show_all": "", "asint": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "target": "high", "show_all": "true", "asint": "true", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_demark(params, obb): +def test_ta_demark(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.demark(**params) assert result @@ -349,15 +379,16 @@ def test_ta_demark(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "anchor": "", "offset": ""}), - ({"data": get_crypto_data(), "index": "date", "anchor": "W", "offset": "5"}), + ({"data": "", "index": "", "anchor": "", "offset": ""}, "stocks"), + ({"data": "", "index": "date", "anchor": "W", "offset": "5"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_vwap(params, obb): +def test_ta_vwap(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.vwap(**params) assert result @@ -366,33 +397,36 @@ def test_ta_vwap(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "fast": "", "slow": "", "signal": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "fast": "10", "slow": "30", "signal": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_macd(params, obb): +def test_ta_macd(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.macd(**params) assert result @@ -401,31 +435,34 @@ def test_ta_macd(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "55", "offset": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_hma(params, obb): +def test_ta_hma(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.hma(**params) assert result @@ -434,31 +471,34 @@ def test_ta_hma(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "lower_length": "", "upper_length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "lower_length": "30", "upper_length": "40", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_donchian(params, obb): +def test_ta_donchian(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.donchian(**params) assert result @@ -467,35 +507,38 @@ def test_ta_donchian(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "conversion": "", "base": "", "lagging": "", "offset": "", "lookahead": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "conversion": "10", "base": "30", "lagging": "50", "offset": "30", "lookahead": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_ichimoku(params, obb): +def test_ta_ichimoku(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.ichimoku(**params) assert result @@ -504,22 +547,24 @@ def test_ta_ichimoku(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "target": "", "period": ""}), + ({"data": "", "index": "", "target": "", "period": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "target": "close", "period": "95", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_clenow(params, obb): +def test_ta_clenow(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.clenow(**params) assert result @@ -528,31 +573,34 @@ def test_ta_clenow(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "scalar": "", "drift": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "60", "scalar": "90.0", "drift": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_adx(params, obb): +def test_ta_adx(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.adx(**params) assert result @@ -561,31 +609,34 @@ def test_ta_adx(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "60", "offset": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_wma(params, obb): +def test_ta_wma(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.wma(**params) assert result @@ -594,22 +645,24 @@ def test_ta_wma(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}), + ({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "16", "scalar": "0.02", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_cci(params, obb): +def test_ta_cci(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.cci(**params) assert result @@ -618,33 +671,36 @@ def test_ta_cci(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "", "index": "", "length": "", "scalar": "", "drift": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "date", "length": "16", "scalar": "90.0", "drift": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_rsi(params, obb): +def test_ta_rsi(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.rsi(**params) assert result @@ -653,31 +709,34 @@ def test_ta_rsi(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "fast_k_period": "", "slow_d_period": "", "slow_k_period": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "fast_k_period": "12", "slow_d_period": "2", "slow_k_period": "2", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_stoch(params, obb): +def test_ta_stoch(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.stoch(**params) assert result @@ -686,33 +745,36 @@ def test_ta_stoch(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "length": "", "scalar": "", "mamode": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "length": "22", "scalar": "24", "mamode": "sma", "offset": "5", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_kc(params, obb): +def test_ta_kc(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.kc(**params) assert result @@ -721,15 +783,16 @@ def test_ta_kc(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ - ({"data": get_stocks_data(), "index": "", "length": ""}), - ({"data": get_crypto_data(), "index": "date", "length": "20"}), + ({"data": "", "index": "", "length": ""}, "stocks"), + ({"data": "", "index": "date", "length": "20"}, "crypto"), ], ) @pytest.mark.integration -def test_ta_cg(params, obb): +def test_ta_cg(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.cg(**params) assert result @@ -738,33 +801,36 @@ def test_ta_cg(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "index": "", "lower_q": "", "upper_q": "", "model": "", "is_crypto": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "index": "date", "lower_q": "0.3", "upper_q": "0.7", "model": "Parkinson", "is_crypto": "true", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_cones(params, obb): +def test_ta_cones(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.cones(**params) assert result @@ -773,31 +839,34 @@ def test_ta_cones(params, obb): @pytest.mark.parametrize( - "params", + "params, data_type", [ ( { - "data": get_stocks_data(), + "data": "", "target": "close", "index": "date", "length": "", "offset": "", - } + }, + "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "target": "high", "index": "", "length": "60", "offset": "10", - } + }, + "crypto", ), ], ) @pytest.mark.integration -def test_ta_ema(params, obb): +def test_ta_ema(params, data_type, obb): params = {p: v for p, v in params.items() if v} + params["data"] = get_data(data_type) result = obb.ta.ema(**params) assert result From 9e569eb2aa88945f892449887807c5cec45f3764 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:35:33 +0200 Subject: [PATCH 34/45] Lint --- .../extensions/tests/utils/integration_tests_testers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 38b560bc71d..00f6463440e 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -97,13 +97,13 @@ def check_missing_params( for expected_param in command_params[provider]["QueryParams"][ "fields" ]: - if expected_param not in test_params.keys(): + if expected_param not in test_params: missing_params.append( f"Missing param {expected_param} for provider {provider} in function {function}" ) elif isinstance(command_params, dict): for expected_param in command_params["openbb"]["QueryParams"]["fields"]: - if expected_param not in test_params.keys(): + if expected_param not in test_params: missing_params.append( f"Missing standard param {expected_param} in function {function}" ) From 2bde8e8fabaaea676615b8a05d6df0bb2bb48a91 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:37:55 +0200 Subject: [PATCH 35/45] Cleanup --- .../extensions/tests/test_integration_tests_api.py | 7 ------- .../extensions/tests/test_integration_tests_python.py | 4 ---- 2 files changed, 11 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index a9adaec9c11..6aadd20ae77 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,5 +1,4 @@ """Test the integration tests.""" -import pytest from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, @@ -17,17 +16,11 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) -# TODO: Check if this can work without being an integration test -@pytest.mark.integration def test_api_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("api", check_missing_integration_test_providers) -@pytest.mark.integration def test_api_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("api", check_missing_integration_test_params) - - -test_api_interface_integration_test_params() diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 1303b8ed62b..0575ebdc64e 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,5 +1,4 @@ """Test the integration tests.""" -import pytest from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, @@ -17,14 +16,11 @@ def run_test(test_type: str, check_function) -> None: assert not missing_items, "\n".join(missing_items) -# TODO: Check if this can work without being an integration test -@pytest.mark.integration def test_python_interface_integration_test_providers() -> None: """Test if there are any missing providers for integration tests.""" run_test("python", check_missing_integration_test_providers) -@pytest.mark.integration def test_python_interface_integration_test_params() -> None: """Test if there are any missing params for integration tests.""" run_test("python", check_missing_integration_test_params) From 0874b9988d9956ef3db7d3ed530fba2bfa34c704 Mon Sep 17 00:00:00 2001 From: Igor Radovanovic <74266147+IgorWounds@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:52:24 +0200 Subject: [PATCH 36/45] Change path --- openbb_platform/extensions/tests/test_integration_tests_api.py | 2 +- .../extensions/tests/test_integration_tests_python.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 6aadd20ae77..24e077d8e6c 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,5 +1,5 @@ """Test the integration tests.""" -from extensions.tests.utils.integration_tests_testers import ( +from .utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 0575ebdc64e..501d9c331ae 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,5 +1,5 @@ """Test the integration tests.""" -from extensions.tests.utils.integration_tests_testers import ( +from .utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, From 2f89ee09f7ebf41d08dd59460a0241a0ae19902a Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 10:42:21 +0100 Subject: [PATCH 37/45] solving naming issues on pytest --- .../platform/core/tests/__init__.py | 0 ...test_router.py => test_platform_router.py} | 0 .../platform/core/tests/test_query.py | 125 ------------------ 3 files changed, 125 deletions(-) delete mode 100644 openbb_platform/platform/core/tests/__init__.py rename openbb_platform/platform/core/tests/app/{test_router.py => test_platform_router.py} (100%) delete mode 100644 openbb_platform/platform/core/tests/test_query.py diff --git a/openbb_platform/platform/core/tests/__init__.py b/openbb_platform/platform/core/tests/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/openbb_platform/platform/core/tests/app/test_router.py b/openbb_platform/platform/core/tests/app/test_platform_router.py similarity index 100% rename from openbb_platform/platform/core/tests/app/test_router.py rename to openbb_platform/platform/core/tests/app/test_platform_router.py diff --git a/openbb_platform/platform/core/tests/test_query.py b/openbb_platform/platform/core/tests/test_query.py deleted file mode 100644 index d4df7740ce2..00000000000 --- a/openbb_platform/platform/core/tests/test_query.py +++ /dev/null @@ -1,125 +0,0 @@ -"""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, ConfigDict - - -class MockBaseModel(BaseModel): - """Mock BaseModel class.""" - - model_config = ConfigDict(extra="allow", populate_by_name=True) - - -def create_mock_query(): - """Mock query.""" - - class StockHistorical: - """Mock StockHistorical class.""" - - start_date = "2020-01-01" - end_date = "2020-01-05" - symbol = "AAPL" - - return StockHistorical() - - -def create_mock_extra_params(): - """Mock ExtraParams dataclass.""" - - @dataclass - class StockHistorical: - """Mock ExtraParams dataclass.""" - - sort: str = "desc" - - return StockHistorical() - - -@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_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 StockHistorical: - """Mock ExtraParams dataclass.""" - - sort: str = "desc" - limit: int = 4 - - extra_params = StockHistorical() - - assert not query.filter_extra_params(extra_params, "fmp") - - -@pytest.fixture -def mock_registry(): - """Mock registry.""" - with patch( - "openbb_core.app.provider_interface.ProviderInterface" - ) 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 = MockBaseModel() - mock_registry.fetch.return_value = mock_fetch_result - - with pytest.raises(Exception): - query_instance.execute() From 45a758251aa6a6d7acdfcae4e21cb658e91ebb69 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 11:05:15 +0100 Subject: [PATCH 38/45] solving econometrics instantiating wrong openbb --- .../integration/test_econometrics_api.py | 2 +- .../integration/test_econometrics_python.py | 52 +++++++++---------- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py index 91a8a3a2968..d2927a8e376 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_api.py @@ -41,7 +41,7 @@ def get_stocks_data(): return data["stocks_data"] -def get_crypto_data(headers): +def get_crypto_data(): if "crypto_data" in data: return data["crypto_data"] diff --git a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py index 70ed77654a3..81d0e71201e 100644 --- a/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py +++ b/openbb_platform/extensions/econometrics/integration/test_econometrics_python.py @@ -77,11 +77,11 @@ def test_econometrics_corr(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -101,8 +101,8 @@ def test_econometrics_ols(params, data_type, obb): @pytest.mark.parametrize( "params", [ - ({"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}), - ({"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}), + ({"data": "", "y_column": "close", "x_columns": ["date"]}), + ({"data": "", "y_column": "close", "x_columns": ["date"]}), ], ) @pytest.mark.integration @@ -119,11 +119,11 @@ def test_econometrics_ols_summary(params, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "volume", "x_columns": ["close"]}, + {"data": "", "y_column": "volume", "x_columns": ["close"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "volume", "x_columns": ["close"]}, + {"data": "", "y_column": "volume", "x_columns": ["close"]}, "crypto", ), ], @@ -144,7 +144,7 @@ def test_econometrics_dwat(params, data_type, obb): [ ( { - "data": get_stocks_data(), + "data": "", "y_column": "volume", "x_columns": ["close"], "lags": "", @@ -153,7 +153,7 @@ def test_econometrics_dwat(params, data_type, obb): ), ( { - "data": get_crypto_data(), + "data": "", "y_column": "volume", "x_columns": ["close"], "lags": "2", @@ -178,14 +178,14 @@ def test_econometrics_bgot(params, data_type, obb): [ ( { - "data": get_stocks_data(), + "data": "", "columns": ["close", "volume"], }, "stocks", ), ( { - "data": get_crypto_data(), + "data": "", "columns": ["close", "volume"], }, "crypto", @@ -209,7 +209,7 @@ def test_econometrics_coint(params, data_type, obb): [ ( { - "data": get_stocks_data(), + "data": "", "y_column": "volume", "x_column": "close", "lag": "", @@ -218,7 +218,7 @@ def test_econometrics_coint(params, data_type, obb): ), ( { - "data": get_crypto_data(), + "data": "", "y_column": "volume", "x_column": "close", "lag": "2", @@ -242,9 +242,9 @@ def test_econometrics_granger(params, data_type, obb): @pytest.mark.parametrize( "params, data_type", [ - ({"data": get_stocks_data(), "column": "close", "regression": "c"}, "stocks"), + ({"data": "", "column": "close", "regression": "c"}, "stocks"), ( - {"data": get_crypto_data(), "column": "volume", "regression": "ctt"}, + {"data": "", "column": "volume", "regression": "ctt"}, "crypto", ), ], @@ -264,11 +264,11 @@ def test_econometrics_unitroot(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -289,11 +289,11 @@ def test_econometrics_panelre(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -314,11 +314,11 @@ def test_econometrics_panelbols(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -339,11 +339,11 @@ def test_econometrics_panelpols(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -364,11 +364,11 @@ def test_econometrics_panelols(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], @@ -389,11 +389,11 @@ def test_econometrics_panelfd(params, data_type, obb): "params, data_type", [ ( - {"data": get_stocks_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "stocks", ), ( - {"data": get_crypto_data(), "y_column": "close", "x_columns": ["date"]}, + {"data": "", "y_column": "close", "x_columns": ["date"]}, "crypto", ), ], From 6b1aebb22743ca9270e41c167a45a4ec383382f5 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 11:15:30 +0100 Subject: [PATCH 39/45] chaging the way pytest runs --- .github/workflows/platform-api-integration-test.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index 9490b6e4978..a3abd3367c8 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -19,8 +19,8 @@ jobs: env: SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }} OPENBB_API_AUTH: true - OPENBB_API_USERNAME: 'USER' - OPENBB_API_PASSWORD: 'PASS' + OPENBB_API_USERNAME: "USER" + OPENBB_API_PASSWORD: "PASS" steps: - name: Slack Notification - Starting @@ -111,7 +111,7 @@ jobs: source runner_env/bin/activate pip list cd openbb_platform - pytest . -m integration + pytest -m integration - name: Cache pip packages uses: actions/cache@v2 From f2cf772d7937ca3583a784fca2e1ce814b19842e Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 11:27:12 +0100 Subject: [PATCH 40/45] messing around with the imports --- openbb_platform/extensions/__init__.py | 0 openbb_platform/extensions/tests/test_integration_tests_api.py | 2 +- .../extensions/tests/test_integration_tests_python.py | 2 +- 3 files changed, 2 insertions(+), 2 deletions(-) create mode 100644 openbb_platform/extensions/__init__.py diff --git a/openbb_platform/extensions/__init__.py b/openbb_platform/extensions/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/openbb_platform/extensions/tests/test_integration_tests_api.py b/openbb_platform/extensions/tests/test_integration_tests_api.py index 24e077d8e6c..6aadd20ae77 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_api.py +++ b/openbb_platform/extensions/tests/test_integration_tests_api.py @@ -1,5 +1,5 @@ """Test the integration tests.""" -from .utils.integration_tests_testers import ( +from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, diff --git a/openbb_platform/extensions/tests/test_integration_tests_python.py b/openbb_platform/extensions/tests/test_integration_tests_python.py index 501d9c331ae..0575ebdc64e 100644 --- a/openbb_platform/extensions/tests/test_integration_tests_python.py +++ b/openbb_platform/extensions/tests/test_integration_tests_python.py @@ -1,5 +1,5 @@ """Test the integration tests.""" -from .utils.integration_tests_testers import ( +from extensions.tests.utils.integration_tests_testers import ( check_missing_integration_test_params, check_missing_integration_test_providers, get_integration_tests, From 7fd53367740acf656ffdd9a8275e8a1cba944c31 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 11:42:42 +0100 Subject: [PATCH 41/45] ruff --- .../tests/utils/integration_tests_api_generator.py | 3 ++- .../extensions/tests/utils/integration_tests_testers.py | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py index dfa6dd06e3b..d77df54d2b5 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_api_generator.py @@ -2,10 +2,11 @@ import os from typing import Dict, List, Type, get_type_hints import requests -from extensions.tests.utils.integration_tests_generator import get_test_params from openbb_core.app.provider_interface import ProviderInterface from openbb_core.app.router import CommandMap +from extensions.tests.utils.integration_tests_generator import get_test_params + def get_http_method(api_paths: Dict[str, dict], route: str): route_info = api_paths.get(route, None) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_testers.py b/openbb_platform/extensions/tests/utils/integration_tests_testers.py index 00f6463440e..ced6ad7c725 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_testers.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_testers.py @@ -4,12 +4,13 @@ import inspect import os from typing import Any, Callable, Dict, List, Literal, Tuple, Union, get_type_hints +from openbb_core.app.provider_interface import ProviderInterface +from openbb_core.app.router import CommandMap + from extensions.tests.utils.integration_tests_generator import ( find_extensions, get_test_params_data_processing, ) -from openbb_core.app.provider_interface import ProviderInterface -from openbb_core.app.router import CommandMap def get_integration_tests(test_type: Literal["api", "python"]) -> List[Any]: From 687be731e8eaee2475080f807e2fc72a995a4a48 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 12:13:28 +0100 Subject: [PATCH 42/45] solving __pycache__ issue --- .../extensions/tests/utils/integration_tests_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openbb_platform/extensions/tests/utils/integration_tests_generator.py b/openbb_platform/extensions/tests/utils/integration_tests_generator.py index 2e2ed72280d..2d4ecc6200e 100644 --- a/openbb_platform/extensions/tests/utils/integration_tests_generator.py +++ b/openbb_platform/extensions/tests/utils/integration_tests_generator.py @@ -26,7 +26,7 @@ def test_{test_name}(params, obb): def find_extensions(): """Find extensions.""" - filter_ext = ["tests", "charting"] + filter_ext = ["tests", "charting", "__pycache__"] extensions = [x for x in Path("openbb_platform/extensions").iterdir() if x.is_dir()] extensions = [x for x in extensions if x.name not in filter_ext] return extensions From 86e8118e9a52981a736072de0add860fe8f79aa2 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 12:15:20 +0100 Subject: [PATCH 43/45] removing typo --- openbb_platform/tests/conftest.py | 1 - 1 file changed, 1 deletion(-) diff --git a/openbb_platform/tests/conftest.py b/openbb_platform/tests/conftest.py index 7d19c5f6572..c35312c6cda 100644 --- a/openbb_platform/tests/conftest.py +++ b/openbb_platform/tests/conftest.py @@ -1,4 +1,3 @@ # TODO: See if we can dynamically import the test modules under the openbb_platform -# f # TODO: Add global fixture for headers here From 160f807a23b5b91b6fc3ebd92548fb4571b1198f Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 12:19:30 +0100 Subject: [PATCH 44/45] ci yml --- .github/workflows/platform-api-integration-test.yml | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/.github/workflows/platform-api-integration-test.yml b/.github/workflows/platform-api-integration-test.yml index a3abd3367c8..02545c85764 100644 --- a/.github/workflows/platform-api-integration-test.yml +++ b/.github/workflows/platform-api-integration-test.yml @@ -1,12 +1,6 @@ name: API Integration Tests on: - pull_request: - branches: - - feature/openbb-sdk-v4 - push: - branches: - - feature/openbb-sdk-v4 workflow_dispatch: concurrency: @@ -66,7 +60,8 @@ jobs: ./openbb_platform/providers/intrinio \ ./openbb_platform/extensions/futures \ ./openbb_platform/extensions/qa \ - ./openbb_platform/extensions/ta + ./openbb_platform/extensions/ta \ + ./openbb_platform/extensions/econometrics pip uninstall -y openbb_core pip uninstall -y openbb_provider cd openbb_platform/platform/core From 24ce3e9bb877272fde2664f5b5fe7626b1c8db16 Mon Sep 17 00:00:00 2001 From: hjoaquim Date: Mon, 9 Oct 2023 12:25:54 +0100 Subject: [PATCH 45/45] making linters happy (i guess) --- .../platform/core/tests/api/test_auth/test_user_auth.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/openbb_platform/platform/core/tests/api/test_auth/test_user_auth.py b/openbb_platform/platform/core/tests/api/test_auth/test_user_auth.py index 3c99e64cefb..27909f01403 100644 --- a/openbb_platform/platform/core/tests/api/test_auth/test_user_auth.py +++ b/openbb_platform/platform/core/tests/api/test_auth/test_user_auth.py @@ -12,9 +12,6 @@ from openbb_core.api.auth.user import ( ) -# ruff: noqa: S105 S106 - - @pytest.mark.parametrize( "error, correct, received", [