Feature/int tests data processing (#5526)

* adjustments to the generator

* econometrics

* qa

* ta

* improving api tests

* adjustments to python tests

* test ci

* Revert "test ci"

This reverts commit 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

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)