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(