jerry/OpenBB
1
0
Fork 0
mirror of https://github.com/OpenBB-finance/OpenBB.git synced 2026-10-29 13:32:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Feature/int tests data processing (#5526)

Browse Source 
* adjustments to the generator

* econometrics

* qa

* ta

* improving api tests

* adjustments to python tests

* test ci

* Revert "test ci"

This reverts commit 9dce362920.

* remove changes from package

* removing packaged stuff
This commit is contained in:
Henrique Joaquim
2023-10-04 14:56:43 +01:00
committed by GitHub
parent 98771e060e
commit 04d705e43e
7 changed files with 781 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
openbb_platform/extensions/econometrics/integration/test_econometrics_api.py
View File

@@ -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

147
openbb_platform/extensions/econometrics/integration/test_econometrics_python.py
View File

@@ -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)

95
openbb_platform/extensions/qa/integration/test_qa_api.py
View File

@@ -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

195
openbb_platform/extensions/qa/integration/test_qa_python.py
View File

@@ -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

140
openbb_platform/extensions/ta/integration/test_ta_api.py
View File

@@ -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",

366
openbb_platform/extensions/ta/integration/test_ta_python.py
View File

@@ -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)

4
openbb_platform/extensions/tests/utils/integration_tests_generator.py
View File

@@ -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(