def test_linearity_mul(self, a, seed):
universe = make_randomwalk(seed=seed)
trade0 = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
tradeA = a * trade0
result0 = trade0._array_value(universe)
resultA = tradeA._array_value(universe)
assert np.allclose(a * result0, resultA)
def test_random(self, seed):
universe = make_randomwalk(n_bars=100, n_assets=10, seed=seed)
trade = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
result = trade.final_pnl(universe)
expected = trade.array_pnl(universe)[-1]
assert np.allclose(result, expected)
def test_strategy_evaluate(self, MetricClass, seed):
"""
Test if `strategy.evaluate(metric) == metric.result(strategy)`
"""
m = MetricClass()
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = np.array(m.result(strategy)) # from metric method
result1 = np.array(strategy.evaluate(m)) # from strategy method
assert np.equal(result0, result1).all()
def test_linearity_mul(self, a, net, seed):
universe = make_randomwalk(seed=seed)
trade0 = RandomTrader(n_trades=1, seed=seed).run(universe).trades[0]
tradeA = a * trade0
result0 = trade0.series_exposure(universe, net=net)
resultA = tradeA.series_exposure(universe, net=net)
if net:
assert np.allclose(a * result0, resultA)
else:
assert np.allclose(abs(a) * result0, resultA)
def test_series_type():
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
series_wealth = wealth.to_series()
assert isinstance(series_wealth, pd.Series)
def test_series_value():
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
series_wealth = wealth.to_series()
assert np.array_equal(series_wealth, wealth["wealth"])
def test_notrunerror(self, MetricClass):
"""
Metric is supposed to raise NotRunError when one tries to evaluate it
for a strategy which has not been run yet.
"""
m = MetricClass()
with pytest.raises(NotRunError):
RandomTrader(seed=42).evaluate(m)
def test_init():
"""
Test if `History(strategy) == strategy.history`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
assert_result_equal(History(strategy), strategy.history)
def test_result(self, seed, rate):
m = self.MetricClass(rate=rate)
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = m.result(strategy)
result1 = m._result_from_wealth(strategy.wealth.wealth)
assert np.equal(result0, result1).all()
def test_init():
"""
Test if `Wealth(strategy) == strategy.wealth`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
assert_result_equal(Wealth(strategy), strategy.wealth)
def test_random(self, rate, n, risk_free_return, seed, init_wealth):
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed),
budget=init_wealth)
result = self.MetricClass(
rate=rate, n=n, risk_free_return=risk_free_return).result(strategy)
r = AverageReturn(rate=rate, n=n).result(strategy)
s = Volatility(rate=rate, n=n).result(strategy)
expected = (r - risk_free_return) / s
assert result == expected
def test_call(self, MetricClass, seed):
"""
Test if `metric.result(strategy) == metric(strategy)`.
"""
m = MetricClass()
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = np.array(m.result(strategy)) # from `result` method
result1 = np.array(m(strategy)) # from __call__
assert np.equal(result0, result1).all()
def test_dataframe_type():
"""
Test if history.to_dataframe is `pandas.DataFrame`.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert isinstance(df_wealth, pd.DataFrame)
def test_dataframe_index():
"""
Test if value of history.to_dataframe is correct
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert_index_equal(df_wealth.index, universe.bars, check_names=False)
def test_dataframe_value():
"""
Test if value of history.to_dataframe is correct
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert array_equal(df_wealth["wealth"].values, wealth.wealth)
def test_strategy_attr(self):
"""
`History.__init__` and `strategy.history` are supposed to give the same results.
"""
universe = make_randomwalk(seed=42)
strategy = RandomTrader(seed=42).run(universe)
result0 = pd.DataFrame(History(strategy)) # from History.__init__
result1 = pd.DataFrame(strategy.history) # from strategy.history
assert_frame_equal(result0, result1)
def test_dataframe_columns():
"""
Test if history.to_dataframe has the expected columns.
"""
universe = make_randomwalk()
strategy = RandomTrader().run(universe)
wealth = Wealth(strategy)
df_wealth = wealth.to_dataframe()
assert df_wealth.index.name == "bars"
assert_index_equal(df_wealth.columns, pd.Index(["wealth"]))
def test_result_from_wealth(self, rate, n, init_wealth):
"""
`m._result_from_wealth(series_wealth) == m.result(strategy.wealth.wealth)`
"""
m = self.MetricClass(rate=rate, n=n)
strategy = RandomTrader(seed=42).run(make_randomwalk(seed=42),
budget=init_wealth)
series_wealth = strategy.budget + strategy.wealth.wealth
result = m.result(strategy)
result_from_wealth = m._result_from_wealth(series_wealth)
assert np.allclose(result, result_from_wealth)
def _get_df_history(self):
strategy = RandomTrader(seed=42).run(make_randomwalk(42))
return History(strategy).to_dataframe()
def test_result(self, seed):
m = self.MetricClass()
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))
result0 = m.result(strategy)
result1 = m._result_from_wealth(strategy.wealth.wealth)
assert result0 == result1
def test_random(self, rate, seed, init_wealth):
strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed),
budget=init_wealth)
result = self.MetricClass(rate=rate, ).result(strategy)
expected = np.min(Drawdown(rate=rate).result(strategy))
assert result == expected
def _get_history(self):
universe = make_randomwalk(seed=42)
strategy = RandomTrader(seed=42).run(universe)
return History(strategy)
